game Class Reference

#include <game.h>

Classes
class	Creature_range
class	debug_hour_timer
class	draw_callback_t
class	monster_range
class	non_dead_range
class	npc_range

Public Types
enum	inventory_item_menu_positon { RIGHT_TERMINAL_EDGE , LEFT_OF_INFO , RIGHT_OF_INFO , LEFT_TERMINAL_EDGE }

Public Member Functions
	game ()
	~game ()
void	load_static_data ()
	Loads static data that does not depend on mods or similar. More...
void	load_core_data (loading_ui &ui)
	Loads core dynamic data. More...
bool	is_core_data_loaded () const
	Returns whether the core data is currently loaded. More...
bool	check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
	Check if mods can be successfully loaded. More...
void	load_world_modfiles (loading_ui &ui)
	Loads core data and mods from the active world. More...
std::string	get_player_base_save_path () const
	Base path for saving player data. More...
std::string	get_world_base_save_path () const
	Base path for saving world data. More...
bool	load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
	Load content packs. More...
void	on_options_changed ()
	Should be invoked whenever options change. More...
void	setup ()
void	serialize (std::ostream &fout)
	Saving and loading functions. More...
void	unserialize (std::istream &fin)
void	unserialize_master (std::istream &fin)
bool	dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
	write statistics to stdout and More...
bool	save ()
	Returns false if saving failed. More...
std::vector< std::string >	list_active_characters ()
	Returns a list of currently active character saves. More...
void	write_memorial_file (const std::string &filename, std::string sLastWords)
	Writes information about the character out to a text file timestamped with the time of the file was made. More...
bool	cleanup_at_end ()
void	start_calendar ()
bool	do_turn ()
	MAIN GAME LOOP. More...
shared_ptr_fast< ui_adaptor >	create_or_get_main_ui_adaptor ()
void	invalidate_main_ui_adaptor () const
void	mark_main_ui_adaptor_resize () const
void	draw ()
void	draw_ter (bool draw_sounds=true)
void	draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
void	add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
void	draw_panels (bool force_draw=false)
cata::optional< tripoint >	get_veh_dir_indicator_location (bool next) const
	Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
void	draw_veh_dir_indicator (bool next)
void	vertical_move (int z, bool force, bool peeking=false)
	Moves the player vertically. More...
void	start_hauling (const tripoint &pos)
cata::optional< tripoint >	find_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
	Returns the other end of the stairs (if any). More...
void	vertical_shift (int z_after)
	Actual z-level movement part of vertical_move. More...
void	vertical_notes (int z_before, int z_after)
	Add goes up/down auto_notes (if turned on) More...
void	use_computer (const tripoint &p)
	Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
template<typename T = Creature>
T *	critter_by_id (const character_id &id)
template<typename T = Creature>
T *	critter_at (const tripoint &p, bool allow_hallucination=false)
	Returns the Creature at the given location. More...
template<typename T = Creature>
const T *	critter_at (const tripoint &p, bool allow_hallucination=false) const
template<typename T = Creature>
shared_ptr_fast< T >	shared_from (const T &critter)
	Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
size_t	num_creatures () const
	Returns the approximate number of creatures in the reality bubble. More...
bool	update_zombie_pos (const monster &critter, const tripoint &pos)
	Redirects to the creature_tracker update_pos() function. More...
void	remove_zombie (const monster &critter)
void	clear_zombies ()
	Redirects to the creature_tracker clear() function. More...
bool	spawn_hallucination (const tripoint &p)
	Spawns a hallucination at a determined position. More...
bool	swap_critters (Creature &, Creature &)
	Swaps positions of two creatures. More...
Creature_range	all_creatures ()
	Returns an anonymous range that contains all creatures. More...
monster_range	all_monsters ()
	Same as all_creatures but iterators only over monsters. More...
npc_range	all_npcs ()
	Same as all_creatures but iterators only over npcs. More...
std::vector< Creature * >	get_creatures_if (const std::function< bool(const Creature &)> &pred)
	Returns all creatures matching a predicate. More...
std::vector< npc * >	get_npcs_if (const std::function< bool(const npc &)> &pred)
Creature *	get_creature_if (const std::function< bool(const Creature &)> &pred)
	Returns a creature matching a predicate. More...
bool	is_empty (const tripoint &p)
	Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
bool	is_in_sunlight (const tripoint &p)
	Returns true if p is outdoors and it is sunny. More...
bool	is_sheltered (const tripoint &p)
	Returns true if p is indoors, underground, or in a car. More...
bool	revive_corpse (const tripoint &p, item &it)
	Revives a corpse at given location. More...
void	save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
	Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
bool	cancel_activity_query (const std::string &text)
	Asks if the player wants to cancel their activity, and if so cancels it. More...
bool	cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
	Asks if the player wants to cancel their activity and if so cancels it. More...
void	moving_vehicle_dismount (const tripoint &dest_loc)
	Handles players exiting from moving vehicles. More...
vehicle *	remoteveh ()
	Returns the current remotely controlled vehicle. More...
void	setremoteveh (vehicle *veh)
	Sets the current remotely controlled vehicle. More...
int	assign_mission_id ()
	Returns the next available mission id. More...
npc *	find_npc (character_id id)
	Find the npc with the given ID. More...
void	load_npcs ()
	Makes any nearby NPCs on the overmap active. More...
void	reload_npcs ()
	Unloads, then loads the NPCs. More...
const kill_tracker &	get_kill_tracker () const
void	add_npc_follower (const character_id &id)
	Add follower id to set of followers. More...
void	remove_npc_follower (const character_id &id)
	Remove follower id from follower set. More...
std::set< character_id >	get_follower_list ()
	Get set of followers. More...
void	validate_npc_followers ()
	validate list of followers to account for overmap buffers More...
void	validate_mounted_npcs ()
void	validate_linked_vehicles ()
	validate towed vehicles so they get linked up again after a load More...
void	validate_camps ()
	validate camps to ensure they are on the overmap list More...
void	autopilot_vehicles ()
	process vehicles that are following the player More...
void	catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
	Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
std::unordered_set< tripoint >	get_fishable_locations (int distance, const tripoint &fish_pos)
	Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
std::vector< monster * >	get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
	Get the fishable monsters within the provided fishable locations. More...
void	fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
	Flings the input creature in the given direction. More...
float	natural_light_level (int zlev) const
unsigned char	light_level (int zlev) const
	Returns coarse number-of-squares of visibility at the current light level. More...
void	reset_light_level ()
character_id	assign_npc_id ()
Creature *	is_hostile_nearby ()
Creature *	is_hostile_very_close ()
point	update_map (player &p)
point	update_map (int &x, int &y)
void	update_overmap_seen ()
void	process_artifact (item &it, player &p)
void	add_artifact_messages (const std::vector< art_effect_passive > &effects)
void	add_artifact_dreams ()
void	peek ()
void	peek (const tripoint &p)
cata::optional< tripoint >	look_debug ()
bool	check_zone (const zone_type_id &type, const tripoint &where) const
bool	check_near_zone (const zone_type_id &type, const tripoint &where) const
	Checks whether or not there is a zone of particular type nearby. More...
bool	is_zones_manager_open () const
void	zones_manager ()
cata::optional< tripoint >	look_around ()
look_around_result	look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
void	pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
void	print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
void	draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
void	extended_description (const tripoint &p)
	Long description of (visible) things at tile. More...
void	draw_trail_to_square (const tripoint &t, bool bDrawX)
int	inventory_item_menu (item_location locThisItem, const std::function< int()> &startx=[]() { return 0;}, const std::function< int()> &width=[]() { return 50;}, inventory_item_menu_positon position=RIGHT_OF_INFO)
item_location	inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
	Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
bool	has_gametype () const
special_game_id	gametype () const
void	toggle_fullscreen ()
void	toggle_pixel_minimap ()
void	reload_tileset ()
void	temp_exit_fullscreen ()
void	reenter_fullscreen ()
void	zoom_in ()
void	zoom_out ()
void	reset_zoom ()
void	set_zoom (int level)
int	get_zoom () const
int	get_moves_since_last_save () const
int	get_user_action_counter () const
bool	take_screenshot (const std::string &file_path) const
	Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
bool	take_screenshot () const
	Saves a screenshot of the current viewport, as a PNG file. More...
int	get_levx () const
	The top left corner of the reality bubble (in submaps coordinates). More...
int	get_levy () const
int	get_levz () const
void	load_map (const tripoint &pos_sm)
	Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
void	load_map (const tripoint_abs_sm &pos_sm)
overmap &	get_cur_om () const
	The overmap which contains the center submap of the reality bubble. More...
std::vector< npc * >	allies ()
	Get all living player allies. More...
void	set_driving_view_offset (const point &p)
void	calc_driving_offset (vehicle *veh=nullptr)
void	open_gate (const tripoint &p)
void	knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
void	knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
void	draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
void	draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
void	draw_hit_player (const Character &p, int dam)
void	draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
void	draw_line (const tripoint &p, const std::vector< tripoint > &points)
void	draw_weather (const weather_printable &wPrint)
void	draw_sct ()
void	draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
void	draw_critter (const Creature &critter, const tripoint &center)
void	draw_critter_highlighted (const Creature &critter, const tripoint &center)
void	draw_cursor (const tripoint &p)
void	draw_highlight (const tripoint &p)
void	draw_radiation_override (const tripoint &p, int rad)
void	draw_terrain_override (const tripoint &p, const ter_id &id)
void	draw_furniture_override (const tripoint &p, const furn_id &id)
void	draw_graffiti_override (const tripoint &p, bool has)
void	draw_trap_override (const tripoint &p, const trap_id &id)
void	draw_field_override (const tripoint &p, const field_type_id &id)
void	draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
void	draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
void	draw_below_override (const tripoint &p, bool draw)
void	draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
bool	is_in_viewport (const tripoint &p, int margin=0) const
bool	check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
	Check whether movement is allowed according to safe mode settings. More...
void	set_safe_mode (safe_mode_type mode)
void	exam_vehicle (vehicle &veh, const point &cp=point_zero)
	open vehicle interaction screen More...
bool	forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
bool	load (const std::string &world)
	Attempt to load first valid save (if any) in world. More...
bool	npc_menu (npc &who)
	Returns true if the menu handled stuff and player shouldn't do anything else. More...
bool	phasing_move (const tripoint &dest, bool via_ramp=false)
bool	walk_move (const tripoint &dest, bool via_ramp=false)
void	on_move_effects ()
void	reload (item_location &loc, bool prompt=false, bool empty=true)
void	reload_item ()
void	reload_wielded (bool prompt=false)
void	reload_weapon (bool try_everything=true)
point	place_player (const tripoint &dest)
void	place_player_overmap (const tripoint_abs_omt &om_dest)
bool	unload (item_location loc)
unsigned int	get_seed () const
void	set_npcs_dirty ()
	If invoked, NPCs will be reloaded before next turn. More...
void	set_critter_died ()
	If invoked, dead will be cleaned this turn. More...
void	mon_info (const catacurses::window &, int hor_padding=0)
void	mon_info_update ()
void	cleanup_dead ()
bool	is_dangerous_tile (const tripoint &dest_loc) const
std::vector< std::string >	get_dangerous_tile (const tripoint &dest_loc) const
bool	prompt_dangerous_tile (const tripoint &dest_loc) const
void	despawn_monster (monster &critter)
	Despawn a specific monster, it's stored on the overmap. More...
void	win ()
	Marks the game as won. More...
bool	disable_robot (const tripoint &p)
	If there is a robot (that can be disabled), query the player and try to disable it. More...
void	draw_pixel_minimap (const catacurses::window &w)
void	quicksave ()
void	disp_NPCs ()
void	list_missions ()
event_bus &	events ()
stats_tracker &	stats ()
memorial_logger &	memorial ()
spell_events &	spell_events_subscriber ()
void	display_toggle_overlay (action_id)
bool	display_overlay_state (action_id)
void	toggle_debug_hour_timer ()
tripoint	mouse_edge_scrolling_terrain (input_context &ctxt)
	Used to implement mouse "edge scrolling". More...
tripoint	mouse_edge_scrolling_overmap (input_context &ctxt)
	This variant is suitable for the overmap. More...
void	shift_destination_preview (const point &delta)
bool	slip_down ()
	Checks if player is able to successfully climb to/from some terrain and not slip down. More...
monster *	place_critter_at (const mtype_id &id, const tripoint &p)
	Adds critters to the reality bubble, creating them if necessary. More...
monster *	place_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
monster *	place_critter_around (const mtype_id &id, const tripoint &center, int radius)
monster *	place_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
monster *	place_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
monster *	place_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)

Public Attributes
map &	m
avatar &	u
scent_map &	scent
timed_event_manager &	timed_events
pimpl< Creature_tracker >	critter_tracker
pimpl< faction_manager >	faction_manager_ptr
pimpl< drop_token_provider >	token_provider_ptr
quit_status	uquit
	Used in main.cpp to determine what type of quit is being performed. More...
bool	new_game = false
	True if the game has just started or loaded, else false. More...
const scenario *	scen
std::vector< monster >	coming_to_stairs
int	monstairz = 0
tripoint	ter_view_p
catacurses::window	w_terrain
catacurses::window	w_overmap
catacurses::window	w_omlegend
catacurses::window	w_minimap
catacurses::window	w_pixel_minimap
point	driving_view_offset
bool	debug_pathfinding = false
bool	debug_submap_grid_overlay = false
Creature *	displaying_visibility_creature
	Creature for which to display the visibility map. More...
int	displaying_lighting_condition = 0
	Type of lighting condition overlay to display. More...
bool	show_panel_adm = false
bool	right_sidebar = false
bool	fullscreen = false
bool	was_fullscreen = false
bool	auto_travel_mode = false
bool	queue_screenshot = false
safe_mode_type	safe_mode
int	turnssincelastmon = 0
int	mostseen = 0

Protected Member Functions
void	load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
	Loads dynamic data from the given directory. More...

Private Types
enum class	vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }

Private Member Functions
void	unload_npcs ()
	Unloads all NPCs. More...
bool	load (const save_t &name)
void	load_master ()
bool	start_game ()
bool	save_factions_missions_npcs ()
void	reset_npc_dispositions ()
void	serialize_master (std::ostream &fout)
bool	save_artifacts ()
bool	save_maps ()
void	init_autosave ()
void	create_starting_npcs ()
vehicle *	place_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
void	list_items_monsters ()
game::vmenu_ret	list_items (const std::vector< map_item_stack > &item_list)
std::vector< map_item_stack >	find_nearby_items (int iRadius)
void	reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
game::vmenu_ret	list_monsters (const std::vector< Creature * > &monster_list)
bool	grabbed_move (const tripoint &dp)
	Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
bool	grabbed_veh_move (const tripoint &dp)
bool	grabbed_furn_move (const tripoint &dp)
void	control_vehicle ()
void	examine (const tripoint &p)
void	examine ()
void	pickup ()
void	pickup (const tripoint &p)
void	pickup_feet ()
void	drop ()
void	drop_in_direction ()
void	butcher ()
void	wield ()
void	wield (item_location &loc)
void	chat ()
void	print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
void	print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
void	print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
void	print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
void	print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
void	print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
void	print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
void	print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
input_context	get_player_input (std::string &action)
void	replace_stair_monsters ()
void	update_stair_monsters ()
void	shift_monsters (const tripoint &shift)
	Shift all active monsters, the shift vector is the number of shifted submaps. More...
void	perhaps_add_random_npc ()
void	monmove ()
void	overmap_npc_move ()
void	process_voluntary_act_interrupt ()
void	process_activity ()
void	handle_key_blocking_activity ()
void	open_consume_item_menu ()
bool	handle_action ()
bool	try_get_right_click_action (action_id &act, const tripoint &mouse_target)
bool	try_get_left_click_action (action_id &act, const tripoint &mouse_target)
void	item_action_menu ()
bool	is_game_over ()
void	death_screen ()
void	win_screen ()
void	draw_minimap ()
void	autosave ()
void	quickload ()
bool	handle_mouseview (input_context &ctxt, std::string &action)
void	display_faction_epilogues ()
void	disp_NPC_epilogues ()
void	display_scent ()
void	display_temperature ()
void	display_vehicle_ai ()
void	display_visibility ()
void	display_lighting ()
void	display_radiation ()
void	display_transparency ()
Creature *	is_hostile_within (int distance)
void	move_save_to_graveyard (const std::string &dirname)
bool	save_player_data ()
std::pair< tripoint, tripoint >	mouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)

Private Attributes
bool	is_looking = false
std::vector< weak_ptr_fast< draw_callback_t > >	draw_callbacks
cata::optional< action_id >	displaying_overlays
class game::debug_hour_timer	debug_hour_timer
pimpl< map >	map_ptr
pimpl< avatar >	u_ptr
pimpl< live_view >	liveview_ptr
live_view &	liveview
pimpl< scent_map >	scent_ptr
pimpl< timed_event_manager >	timed_event_manager_ptr
pimpl< event_bus >	event_bus_ptr
pimpl< stats_tracker >	stats_tracker_ptr
pimpl< achievements_tracker >	achievements_tracker_ptr
pimpl< kill_tracker >	kill_tracker_ptr
pimpl< memorial_logger >	memorial_logger_ptr
pimpl< spell_events >	spell_events_ptr
pimpl< distribution_grid_tracker >	grid_tracker_ptr
pimpl< weather_manager >	weather_manager_ptr
shared_ptr_fast< player >	u_shared_ptr
catacurses::window	w_terrain_ptr
catacurses::window	w_minimap_ptr
std::string	sFilter
std::string	list_item_upvote
std::string	list_item_downvote
bool	safe_mode_warning_logged = false
bool	bVMonsterLookFire = false
character_id	next_npc_id
std::list< shared_ptr_fast< npc > >	active_npc
int	next_mission_id = 0
std::set< character_id >	follower_ids
int	moves_since_last_save = 0
time_t	last_save_timestamp
std::array< float, OVERMAP_LAYERS >	latest_lightlevels
time_point	remoteveh_cache_time
vehicle *	remoteveh_cache
bool	npcs_dirty = false
	Has a NPC been spawned since last load? More...
bool	critter_died = false
	Has anything died in this turn and needs to be cleaned up? More...
bool	first_redraw_since_waiting_started = true
	Is this the first redraw since waiting (sleeping or activity) started. More...
bool	zones_manager_open = false
	Is Zone manager open or not - changes graphics of some zone tiles. More...
std::unique_ptr< special_game >	gamemode
int	user_action_counter = 0
int	tileset_zoom = 0
	How far the tileset should be zoomed out, 16 is default. More...
unsigned int	seed = 0
	Seed for all the random numbers that should have consistent randomness (weather). More...
std::vector< tripoint >	destination_preview
std::chrono::time_point< std::chrono::steady_clock >	last_mouse_edge_scroll
tripoint	last_mouse_edge_scroll_vector_terrain
tripoint	last_mouse_edge_scroll_vector_overmap
weak_ptr_fast< ui_adaptor >	main_ui_adaptor
std::unique_ptr< static_popup >	wait_popup

Friends
class	editmap
class	advanced_inventory
class	main_menu
class	monster_range
class	Creature_range
distribution_grid_tracker &	get_distribution_grid_tracker ()
	Returns distribution grid tracker that is a part of the global game *g. More...
map &	get_map ()
Character &	get_player_character ()
avatar &	get_avatar ()
weather_manager &	get_weather ()

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

inventory_item_menu_positon

enum game::inventory_item_menu_positon

Enumerator
RIGHT_TERMINAL_EDGE
LEFT_OF_INFO
RIGHT_OF_INFO
LEFT_TERMINAL_EDGE

Definition at line 611 of file game.h.

                                         {
            RIGHT_TERMINAL_EDGE,
            LEFT_OF_INFO,
            RIGHT_OF_INFO,
            LEFT_TERMINAL_EDGE,
        };

vmenu_ret

enum class game::vmenu_ret : int

strongprivate

Enumerator
CHANGE_TAB
QUIT
FIRE

Definition at line 805 of file game.h.

                             : int {
            CHANGE_TAB,
            QUIT,
            FIRE, // Who knew, apparently you can do that in list_monsters
        };

Constructor & Destructor Documentation

game()

game::game

(

)

Definition at line 283 of file game.cpp.

           :
    liveview( *liveview_ptr ),
    scent_ptr( *this ),
    achievements_tracker_ptr( *stats_tracker_ptr, achievement_attained ),
    grid_tracker_ptr( MAPBUFFER ),
    m( *map_ptr ),
    u( *u_ptr ),
    scent( *scent_ptr ),
    timed_events( *timed_event_manager_ptr ),
    uquit( QUIT_NO ),
    new_game( false ),
    safe_mode( SAFE_MODE_ON ),
    mostseen( 0 ),
    u_shared_ptr( &u, null_deleter{} ),
    safe_mode_warning_logged( false ),
    next_npc_id( 1 ),
    next_mission_id( 1 ),
    remoteveh_cache_time( calendar::before_time_starts ),
    user_action_counter( 0 ),
    tileset_zoom( DEFAULT_TILESET_ZOOM ),
    seed( 0 ),
    last_mouse_edge_scroll( std::chrono::steady_clock::now() )
{
    first_redraw_since_waiting_started = true;
    reset_light_level();
    events().subscribe( &*stats_tracker_ptr );
    events().subscribe( &*kill_tracker_ptr );
    events().subscribe( &*memorial_logger_ptr );
    events().subscribe( &*achievements_tracker_ptr );
    events().subscribe( &*spell_events_ptr );
    world_generator = std::make_unique<worldfactory>();
    // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
    // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
}

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

~game()

game::~game ( )

default

Member Function Documentation

add_artifact_dreams()

void game::add_artifact_dreams

(

)

Definition at line 12345 of file game.cpp.

{
    //If player is sleeping, get a dream from a carried artifact
    //Don't need to check that player is sleeping here, that's done before calling
    std::list<item *> art_items = g->u.get_artifact_items();
    std::vector<item *>      valid_arts;
    std::vector<std::vector<std::string>>
                                       valid_dreams; // Tracking separately so we only need to check its req once
    //Pull the list of dreams
    add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
    for( auto &it : art_items ) {
        //Pick only the ones with an applicable dream
        const cata::value_ptr<islot_artifact> &art = it->type->artifact;
        if( art && art->charge_req != ACR_NULL &&
            ( it->ammo_remaining() < it->ammo_capacity() ||
              it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
            add_msg( m_debug, "Checking artifact %s", it->tname() );
            if( check_art_charge_req( *it ) ) {
                add_msg( m_debug, "   Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
                if( art->dream_freq_met   > 0 && x_in_y( art->dream_freq_met,   100 ) ) {
                    add_msg( m_debug, "Adding met dream from %s", it->tname() );
                    valid_arts.push_back( it );
                    valid_dreams.push_back( art->dream_msg_met );
                }
            } else {
                add_msg( m_debug, "   Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
                if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
                    add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
                    valid_arts.push_back( it );
                    valid_dreams.push_back( art->dream_msg_unmet );
                }
            }
        }
    }
    if( !valid_dreams.empty() ) {
        add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
        const int selected = rng( 0, valid_arts.size() - 1 );
        auto it = valid_arts[selected];
        auto msg = random_entry( valid_dreams[selected] );
        const std::string &dream = string_format( _( msg ), it->tname() );
        add_msg( dream );
    } else {
        add_msg( m_debug, "Didn't have any dreams, sorry" );
    }
}

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

add_artifact_messages()

void game::add_artifact_messages

(

const std::vector< art_effect_passive > &

effects

)

Definition at line 12167 of file game.cpp.

{
    int net_str = 0;
    int net_dex = 0;
    int net_per = 0;
    int net_int = 0;
    int net_speed = 0;
 
    for( auto &i : effects ) {
        switch( i ) {
            case AEP_STR_UP:
                net_str += 4;
                break;
            case AEP_DEX_UP:
                net_dex += 4;
                break;
            case AEP_PER_UP:
                net_per += 4;
                break;
            case AEP_INT_UP:
                net_int += 4;
                break;
            case AEP_ALL_UP:
                net_str += 2;
                net_dex += 2;
                net_per += 2;
                net_int += 2;
                break;
            case AEP_STR_DOWN:
                net_str -= 3;
                break;
            case AEP_DEX_DOWN:
                net_dex -= 3;
                break;
            case AEP_PER_DOWN:
                net_per -= 3;
                break;
            case AEP_INT_DOWN:
                net_int -= 3;
                break;
            case AEP_ALL_DOWN:
                net_str -= 2;
                net_dex -= 2;
                net_per -= 2;
                net_int -= 2;
                break;
 
            case AEP_SPEED_UP:
                net_speed += 20;
                break;
            case AEP_SPEED_DOWN:
                net_speed -= 20;
                break;
 
            case AEP_PBLUE:
                break; // No message
 
            case AEP_SNAKES:
                add_msg( m_warning, _( "Your skin feels slithery." ) );
                break;
 
            case AEP_INVISIBLE:
                add_msg( m_good, _( "You fade into invisibility!" ) );
                break;
 
            case AEP_CLAIRVOYANCE:
            case AEP_CLAIRVOYANCE_PLUS:
                add_msg( m_good, _( "You can see through walls!" ) );
                break;
 
            case AEP_SUPER_CLAIRVOYANCE:
                add_msg( m_good, _( "You can see through everything!" ) );
                break;
 
            case AEP_STEALTH:
                add_msg( m_good, _( "Your steps stop making noise." ) );
                break;
 
            case AEP_GLOW:
                add_msg( _( "A glow of light forms around you." ) );
                break;
 
            case AEP_PSYSHIELD:
                add_msg( m_good, _( "Your mental state feels protected." ) );
                break;
 
            case AEP_RESIST_ELECTRICITY:
                add_msg( m_good, _( "You feel insulated." ) );
                break;
 
            case AEP_CARRY_MORE:
                add_msg( m_good, _( "Your back feels strengthened." ) );
                break;
 
            case AEP_FUN:
                add_msg( m_good, _( "You feel a pleasant tingle." ) );
                break;
 
            case AEP_HUNGER:
                add_msg( m_warning, _( "You feel hungry." ) );
                break;
 
            case AEP_THIRST:
                add_msg( m_warning, _( "You feel thirsty." ) );
                break;
 
            case AEP_EVIL:
                add_msg( m_warning, _( "You feel an evil presence…" ) );
                break;
 
            case AEP_SCHIZO:
                add_msg( m_bad, _( "You feel a tickle of insanity." ) );
                break;
 
            case AEP_RADIOACTIVE:
                add_msg( m_warning, _( "Your skin prickles with radiation." ) );
                break;
 
            case AEP_MUTAGENIC:
                add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
                break;
 
            case AEP_ATTENTION:
                add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
                break;
 
            case AEP_FORCE_TELEPORT:
                add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
                break;
 
            case AEP_MOVEMENT_NOISE:
                add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
                break;
 
            case AEP_BAD_WEATHER:
                add_msg( m_warning, _( "You feel storms coming." ) );
                break;
 
            case AEP_SICK:
                add_msg( m_bad, _( "You feel unwell." ) );
                break;
 
            case AEP_SMOKE:
                add_msg( m_warning, _( "A cloud of smoke appears." ) );
                break;
            default:
                //Suppress warnings
                break;
        }
    }
 
    std::string stat_info;
    if( net_str != 0 ) {
        stat_info += string_format( _( "Str %s%d! " ),
                                    ( net_str > 0 ? "+" : "" ), net_str );
    }
    if( net_dex != 0 ) {
        stat_info += string_format( _( "Dex %s%d! " ),
                                    ( net_dex > 0 ? "+" : "" ), net_dex );
    }
    if( net_int != 0 ) {
        stat_info += string_format( _( "Int %s%d! " ),
                                    ( net_int > 0 ? "+" : "" ), net_int );
    }
    if( net_per != 0 ) {
        stat_info += string_format( _( "Per %s%d! " ),
                                    ( net_per > 0 ? "+" : "" ), net_per );
    }
 
    if( !stat_info.empty() ) {
        add_msg( m_neutral, stat_info );
    }
 
    if( net_speed != 0 ) {
        add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
    }
}

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

add_draw_callback()

void game::add_draw_callback

(

shared_ptr_fast< draw_callback_t >

cb

)

Definition at line 3370 of file game.cpp.

{
    draw_callbacks.erase(
        std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
    []( const weak_ptr_fast<draw_callback_t> &cbw ) {
        return cbw.expired();
    } ),
    draw_callbacks.end()
    );
    draw_callbacks.emplace_back( cb );
    cb->added = true;
    invalidate_main_ui_adaptor();
}

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

add_npc_follower()

void game::add_npc_follower

(

const character_id &

id

)

Add follower id to set of followers.

Definition at line 1956 of file game.cpp.

{
    follower_ids.insert( id );
    u.follower_ids.insert( id );
}

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

all_creatures()

game::Creature_range game::all_creatures

(

)

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12501 of file game.cpp.

{
    return Creature_range( *this );
}

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

all_monsters()

game::monster_range game::all_monsters

(

)

Same as all_creatures but iterators only over monsters.

Definition at line 12506 of file game.cpp.

{
    return monster_range( *this );
}

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

all_npcs()

game::npc_range game::all_npcs

(

)

Same as all_creatures but iterators only over npcs.

Definition at line 12511 of file game.cpp.

{
    return npc_range( *this );
}

Referenced by do_turn(), and get_npcs_if().

allies()

std::vector< npc * > game::allies

(

)

Get all living player allies.

Definition at line 12415 of file game.cpp.

{
    return get_npcs_if( [&]( const npc & guy ) {
        if( !guy.is_hallucination() ) {
            return guy.is_ally( g->u );
        } else {
            return false;
        }
    } );
}

References get_npcs_if(), and npc::is_hallucination().

assign_mission_id()

int game::assign_mission_id

(

)

Returns the next available mission id.

Definition at line 1944 of file game.cpp.

{
    int ret = next_mission_id;
    next_mission_id++;
    return ret;
}

References next_mission_id, and cata::hash64_detail::ret.

assign_npc_id()

character_id game::assign_npc_id

(

)

Definition at line 3927 of file game.cpp.

{
    character_id ret = next_npc_id;
    ++next_npc_id;
    return ret;
}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

autopilot_vehicles()

void game::autopilot_vehicles

(

)

process vehicles that are following the player

Definition at line 1750 of file game.cpp.

{
    for( wrapped_vehicle &veh : m.get_vehicles() ) {
        vehicle *&v = veh.v;
        if( v->is_following ) {
            v->drive_to_local_target( g->m.getabs( u.pos() ), true );
        } else if( v->is_patrolling ) {
            v->autopilot_patrol();
        }
    }
}

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), g, map::get_vehicles(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

autosave()

void game::autosave ( )

private

Definition at line 11835 of file game.cpp.

{
    //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
    if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
        return;
    }
    quicksave();    //Driving checks are handled by quicksave()
}

References last_save_timestamp, and quicksave().

Referenced by do_turn().

butcher()

void game::butcher ( )

private

Definition at line 8554 of file game.cpp.

{
    static const std::string salvage_string = "salvage";
    if( u.controlling_vehicle ) {
        add_msg( m_info, _( "You can't butcher while driving!" ) );
        return;
    }
 
    const int factor = u.max_quality( quality_id( "BUTCHER" ) );
    const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
    const std::string no_knife_msg = _( "You don't have a butchering tool." );
    const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
 
    //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
    if( m.has_flag( "SEALED", u.pos() ) ) {
        if( m.sees_some_items( u.pos(), u ) ) {
            add_msg( m_info, _( "You can't access the items here." ) );
        } else if( factor > INT_MIN || factorD > INT_MIN ) {
            add_msg( m_info, no_corpse_msg );
        } else {
            add_msg( m_info, no_knife_msg );
        }
        return;
    }
 
    const item *first_item_without_tools = nullptr;
    // Indices of relevant items
    std::vector<map_stack::iterator> corpses;
    std::vector<map_stack::iterator> disassembles;
    std::vector<map_stack::iterator> salvageables;
    map_stack items = m.i_at( u.pos() );
    const inventory &crafting_inv = u.crafting_inventory();
 
    // TODO: Properly handle different material whitelists
    // TODO: Improve quality of this section
    auto salvage_filter = []( item it ) {
        const auto usable = it.get_usable_item( salvage_string );
        return usable != nullptr;
    };
 
    std::vector< item * > salvage_tools = u.items_with( salvage_filter );
    int salvage_tool_index = INT_MIN;
    item *salvage_tool = nullptr;
    const salvage_actor *salvage_iuse = nullptr;
    if( !salvage_tools.empty() ) {
        salvage_tool = salvage_tools.front();
        salvage_tool_index = u.get_item_position( salvage_tool );
        item *usable = salvage_tool->get_usable_item( salvage_string );
        salvage_iuse = dynamic_cast<const salvage_actor *>(
                           usable->get_use( salvage_string )->get_actor_ptr() );
    }
 
    // Reserve capacity for each to hold entire item set if necessary to prevent
    // reallocations later on
    corpses.reserve( items.size() );
    salvageables.reserve( items.size() );
    disassembles.reserve( items.size() );
 
    // Split into corpses, disassemble-able, and salvageable items
    // It's not much additional work to just generate a corpse list and
    // clear it later, but does make the splitting process nicer.
    for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
        if( it->is_corpse() ) {
            corpses.push_back( it );
        } else {
            if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
                salvageables.push_back( it );
            }
            if( u.can_disassemble( *it, crafting_inv ).success() ) {
                disassembles.push_back( it );
            } else if( !first_item_without_tools ) {
                first_item_without_tools = &*it;
            }
        }
    }
 
    // Clear corpses if butcher and dissect factors are INT_MIN
    if( factor == INT_MIN && factorD == INT_MIN ) {
        corpses.clear();
    }
 
    if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
        if( factor > INT_MIN || factorD > INT_MIN ) {
            add_msg( m_info, no_corpse_msg );
        } else {
            add_msg( m_info, no_knife_msg );
        }
 
        if( first_item_without_tools ) {
            add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
            // Just for the "You need x to disassemble y" messages
            const auto ret = u.can_disassemble( *first_item_without_tools, crafting_inv );
            if( !ret.success() ) {
                add_msg( m_info, "%s", ret.c_str() );
            }
        }
        return;
    }
 
    Creature *hostile_critter = is_hostile_very_close();
    if( hostile_critter != nullptr ) {
        if( !query_yn( _( "You see %s nearby!  Start butchering anyway?" ),
                       hostile_critter->disp_name() ) ) {
            return;
        }
    }
 
    // Magic indices for special butcher options
    enum : int {
        MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
        MULTIBUTCHER,
        MULTIDISASSEMBLE_ONE,
        MULTIDISASSEMBLE_ALL,
        NUM_BUTCHER_ACTIONS
    };
    // What are we butchering (i.e.. which vector to pick indices from)
    enum {
        BUTCHER_CORPSE,
        BUTCHER_DISASSEMBLE,
        BUTCHER_SALVAGE,
        BUTCHER_OTHER // For multisalvage etc.
    } butcher_select = BUTCHER_CORPSE;
    // Index to std::vector of iterators...
    int indexer_index = 0;
 
    // Generate the indexed stacks so we can display them nicely
    const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
    const auto salvage_stacks = generate_butcher_stack_display( salvageables );
    // Always ask before cutting up/disassembly, but not before butchery
    size_t ret = 0;
    if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
        uilist kmenu;
        kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
 
        size_t i = 0;
        // Add corpses, disassembleables, and salvagables to the UI
        add_corpses( kmenu, corpses, i );
        add_disassemblables( kmenu, disassembly_stacks, i );
        if( salvage_iuse && !salvageables.empty() ) {
            add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
        }
 
        if( corpses.size() > 1 ) {
            kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
        }
        if( disassembles.size() > 1 ) {
            int time_to_disassemble = 0;
            int time_to_disassemble_all = 0;
            for( const auto &stack : disassembly_stacks ) {
                const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
                time_to_disassemble += time;
                time_to_disassemble_all += time * stack.second;
            }
 
            kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
                                to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
            kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
                                to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
        }
        if( salvage_iuse && salvageables.size() > 1 ) {
            int time_to_salvage = 0;
            for( const auto &stack : salvage_stacks ) {
                time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
            }
 
            kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
                                to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
        }
 
        kmenu.query();
 
        if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
            return;
        }
 
        ret = static_cast<size_t>( kmenu.ret );
        if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
            butcher_select = BUTCHER_OTHER;
            indexer_index = ret;
        } else if( ret < corpses.size() ) {
            butcher_select = BUTCHER_CORPSE;
            indexer_index = ret;
        } else if( ret < corpses.size() + disassembly_stacks.size() ) {
            butcher_select = BUTCHER_DISASSEMBLE;
            indexer_index = ret - corpses.size();
        } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
            butcher_select = BUTCHER_SALVAGE;
            indexer_index = ret - corpses.size() - disassembly_stacks.size();
        } else {
            debugmsg( "Invalid butchery index: %d", ret );
            return;
        }
    }
 
    if( !u.has_morale_to_craft() ) {
        if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
            add_msg( m_info,
                     _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
        } else {
            add_msg( m_info,
                     _( "You are not in the mood and the prospect of work stops you before you begin." ) );
        }
        return;
    }
    const auto helpers = u.get_crafting_helpers( 3 );
    for( const npc *np : helpers ) {
        add_msg( m_info, _( "%s helps with this task…" ), np->name );
    }
    switch( butcher_select ) {
        case BUTCHER_OTHER:
            switch( indexer_index ) {
                case MULTISALVAGE:
                    u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
                    break;
                case MULTIBUTCHER:
                    butcher_submenu( corpses );
                    for( map_stack::iterator &it : corpses ) {
                        u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
                    }
                    break;
                case MULTIDISASSEMBLE_ONE:
                    u.disassemble_all( true );
                    break;
                case MULTIDISASSEMBLE_ALL:
                    u.disassemble_all( false );
                    break;
                default:
                    debugmsg( "Invalid butchery type: %d", indexer_index );
                    return;
            }
            break;
        case BUTCHER_CORPSE: {
            butcher_submenu( corpses, indexer_index );
            u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
        }
        break;
        case BUTCHER_DISASSEMBLE: {
            // Pick index of first item in the disassembly stack
            item *const target = &*disassembly_stacks[indexer_index].first;
            u.disassemble( item_location( map_cursor( u.pos() ), target ), true );
        }
        break;
        case BUTCHER_SALVAGE: {
            if( !salvage_iuse || !salvage_tool ) {
                debugmsg( "null salve_iuse or salvage_tool" );
            } else {
                // Pick index of first item in the salvage stack
                item *const target = &*salvage_stacks[indexer_index].first;
                item_location item_loc( map_cursor( u.pos() ), target );
                salvage_iuse->cut_up( u, *salvage_tool, item_loc );
            }
        }
        break;
    }
}

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), player::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, player::disassemble(), player::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

calc_driving_offset()

void game::calc_driving_offset

(

vehicle *

veh = nullptr

)

Definition at line 1331 of file game.cpp.

{
    if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
        set_driving_view_offset( point_zero );
        return;
    }
    const int g_light_level = static_cast<int>( light_level( u.posz() ) );
    const int light_sight_range = u.sight_range( g_light_level );
    int sight = std::max( veh_lumi( *veh ), light_sight_range );
 
    // The maximal offset will leave at least this many tiles
    // between the PC and the edge of the main window.
    static const int border_range = 2;
    point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
                      ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
 
    // velocity at or below this results in no offset at all
    static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
    // velocity at or above this results in maximal offset
    static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
                                        vehicles::vmiph_per_tile;
    float velocity = veh->velocity;
    rl_vec2d offset = veh->move_vec();
    if( !veh->skidding && veh->player_in_control( u ) &&
        std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
        // Use the cruise controlled velocity, but only if
        // it is not too different from the actual velocity.
        // The actual velocity changes too often (see above slowdown).
        // Using it makes would make the offset change far too often.
        offset = veh->face_vec();
        velocity = veh->cruise_velocity;
    }
    float rel_offset;
    if( std::fabs( velocity ) < min_offset_vel ) {
        rel_offset = 0;
    } else if( std::fabs( velocity ) > max_offset_vel ) {
        rel_offset = ( velocity > 0 ) ? 1 : -1;
    } else {
        rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
    }
    // Squeeze into the corners, by making the offset vector longer,
    // the PC is still in view as long as both offset.x and
    // offset.y are <= 1
    if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
        offset.y /= std::fabs( offset.x );
        offset.x = ( offset.x > 0 ) ? +1 : -1;
    } else if( std::fabs( offset.y ) > 0.2 ) {
        offset.x /= std::fabs( offset.y );
        offset.y = offset.y > 0 ? +1 : -1;
    }
    offset.x *= rel_offset;
    offset.y *= rel_offset;
    offset.x *= max_offset.x;
    offset.y *= max_offset.y;
    // [ ----@---- ] sight=6
    // [ --@------ ] offset=2
    // [ -@------# ] offset=3
    // can see sights square in every direction, total visible area is
    // (2*sight+1)x(2*sight+1), but the window is only
    // getmaxx(w_terrain) x getmaxy(w_terrain)
    // The area outside of the window is maxoff (sight-getmax/2).
    // If that value is <= 0, the whole visible area fits the window.
    // don't apply the view offset at all.
    // If the offset is > maxoff, only apply at most maxoff, everything
    // above leads to invisible area in front of the car.
    // It will display (getmax/2+offset) squares in one direction and
    // (getmax/2-offset) in the opposite direction (centered on the PC).
    const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
                        ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
    if( maxoff.x <= 0 ) {
        offset.x = 0;
    } else if( offset.x > 0 && offset.x > maxoff.x ) {
        offset.x = maxoff.x;
    } else if( offset.x < 0 && -offset.x > maxoff.x ) {
        offset.x = -maxoff.x;
    }
    if( maxoff.y <= 0 ) {
        offset.y = 0;
    } else if( offset.y > 0 && offset.y > maxoff.y ) {
        offset.y = maxoff.y;
    } else if( offset.y < 0 && -offset.y > maxoff.y ) {
        offset.y = -maxoff.y;
    }
 
    // Turn the offset into a vector that increments the offset toward the desired position
    // instead of setting it there instantly, should smooth out jerkiness.
    const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
 
    const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
                             ( offset_difference.y < 0 ) ? -1 : 1 );
    // Shift the current offset in the direction of the calculated offset by one tile
    // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
    offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
               ( driving_view_offset.x + offset_sign.x ) : offset.x;
    offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
               ( driving_view_offset.y + offset_sign.y ) : offset.y;
 
    set_driving_view_offset( point( offset.x, offset.y ) );
}

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query	(	distraction_type	type,
		const std::string &	text
	)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1789 of file game.cpp.

{
    invalidate_main_ui_adaptor();
    if( u.has_distant_destination() ) {
        if( cancel_auto_move( u, text ) ) {
            return true;
        } else {
            u.set_destination( u.get_auto_move_route(), player_activity( activity_id( "ACT_TRAVELLING" ) ) );
            return false;
        }
    }
    if( !u.activity || u.activity.is_distraction_ignored( type ) ) {
        return false;
    }
    const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
    const auto &allow_key = force_uc ? input_context::disallow_lower_case
                            : input_context::allow_all_keys;
 
    const auto &action = query_popup()
                         .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
                         .message( force_uc ?
                                   pgettext( "cancel_activity_or_ignore_query",
                                           "<color_light_red>%s %s (Case Sensitive)</color>" ) :
                                   pgettext( "cancel_activity_or_ignore_query",
                                           "<color_light_red>%s %s</color>" ),
                                   text, u.activity.get_stop_phrase() )
                         .option( "YES", allow_key )
                         .option( "NO", allow_key )
                         .option( "IGNORE", allow_key )
                         .query()
                         .action;
 
    if( action == "YES" ) {
        u.cancel_activity();
        return true;
    }
    if( action == "IGNORE" ) {
        u.activity.ignore_distraction( type );
        for( auto &activity : u.backlog ) {
            activity.ignore_distraction( type );
        }
    }
 
    ui_manager::redraw();
    refresh_display();
 
    return false;
}

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

cancel_activity_query()

bool game::cancel_activity_query

(

const std::string &

text

)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1838 of file game.cpp.

{
    invalidate_main_ui_adaptor();
    if( u.has_distant_destination() ) {
        if( cancel_auto_move( u, text ) ) {
            return true;
        } else {
            u.set_destination( u.get_auto_move_route(), player_activity( activity_id( "ACT_TRAVELLING" ) ) );
            return false;
        }
    }
    if( !u.activity ) {
        return false;
    }
    if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
        u.cancel_activity();
        u.clear_destination();
        u.resume_backlog_activity();
        return true;
    }
    return false;
}

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

catch_a_monster()

void game::catch_a_monster	(	monster *	fish,
		const tripoint &	pos,
		player *	p,
		const time_duration &	catch_duration
	)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1762 of file game.cpp.

{
    //spawn the corpse, rotten by a part of the duration
    m.add_item_or_charges( pos, item::make_corpse( fish->type->id, calendar::turn + rng( 0_turns,
                           catch_duration ) ) );
    if( u.sees( pos ) ) {
        u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
    }
    //quietly kill the caught
    fish->no_corpse_quiet = true;
    fish->die( p );
}

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

chat()

void game::chat ( )

private

Definition at line 393 of file npctalk.cpp.

{
    int volume = g->u.get_shout_volume();
 
    const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
        // TODO: Get rid of the z-level check when z-level vision gets "better"
        return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
               rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
    } );
    const int available_count = available.size();
    const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
        return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
    } );
    const int follower_count = followers.size();
    const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
        return guy.mission == NPC_MISSION_GUARD_ALLY &&
               guy.companion_mission_role_id != "FACTION_CAMP" &&
               guy.can_hear( u.pos(), volume );
    } );
    const int guard_count = guards.size();
 
    if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
            g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
        g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
        return;
    }
    std::vector<vehicle *> animal_vehicles;
    std::vector<vehicle *> following_vehicles;
    std::vector<vehicle *> magic_vehicles;
    std::vector<vehicle *> magic_following_vehicles;
    for( auto &veh : g->m.get_vehicles() ) {
        auto &v = veh.v;
        if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
            animal_vehicles.push_back( v );
            if( v->is_following ) {
                following_vehicles.push_back( v );
            }
        }
        if( v->magic ) {
            for( const vpart_reference &vp : v->get_all_parts() ) {
                const vpart_info &vpi = vp.info();
                if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
                    magic_vehicles.push_back( v );
                    if( v->is_following ) {
                        magic_following_vehicles.push_back( v );
                    }
                    break;
                }
            }
        }
    }
 
    uilist nmenu;
    nmenu.text = std::string( _( "What do you want to do?" ) );
 
    if( !available.empty() ) {
        nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
                        string_format( _( "Talk to %s" ), available.front()->name ) :
                        _( "Talk to…" )
                      );
    }
    nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
    nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
    if( !animal_vehicles.empty() ) {
        nmenu.addentry( NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, true, 'F',
                        _( "Whistle at your animals pulling vehicles to follow you." ) );
    }
    if( !magic_vehicles.empty() ) {
        nmenu.addentry( NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, true, 'Q',
                        _( "Utter a magical command that will order your magical vehicles to follow you." ) );
    }
    if( !magic_following_vehicles.empty() ) {
        nmenu.addentry( NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, true, 'q',
                        _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
    }
    if( !following_vehicles.empty() ) {
        nmenu.addentry( NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, true, 'S',
                        _( "Whistle at your animals pulling vehicles to stop following you." ) );
    }
    if( !guards.empty() ) {
        nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
                        string_format( _( "Tell %s to follow" ), guards.front()->name ) :
                        _( "Tell someone to follow…" )
                      );
    }
    if( !followers.empty() ) {
        nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
                        string_format( _( "Tell %s to guard" ), followers.front()->name ) :
                        _( "Tell someone to guard…" )
                      );
        nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
        nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
        nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
        nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
                        _( "Tell everyone on your team to prepare for danger" ) );
        nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
                        _( "Tell everyone on your team to relax (Clear Overrides)" ) );
        nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
    }
    std::string message;
    std::string yell_msg;
    bool is_order = true;
    nmenu.query();
 
    if( nmenu.ret < 0 ) {
        return;
    }
 
    switch( nmenu.ret ) {
        case NPC_CHAT_TALK: {
            const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
            if( npcselect < 0 ) {
                return;
            }
            available[npcselect]->talk_to_u();
            break;
        }
        case NPC_CHAT_YELL:
            is_order = false;
            message = _( "loudly." );
            break;
        case NPC_CHAT_SENTENCE: {
            std::string popupdesc = _( "Enter a sentence to yell" );
            string_input_popup popup;
            popup.title( _( "Yell a sentence" ) )
            .width( 64 )
            .description( popupdesc )
            .identifier( "sentence" )
            .max_length( 128 )
            .query();
            yell_msg = popup.text();
            is_order = false;
            break;
        }
        case NPC_CHAT_GUARD: {
            const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
            if( npcselect < 0 ) {
                return;
            }
            if( npcselect == follower_count ) {
                for( npc *them : followers ) {
                    talk_function::assign_guard( *them );
                }
                yell_msg = _( "Everyone guard here!" );
            } else {
                talk_function::assign_guard( *followers[npcselect] );
                yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
            }
            break;
        }
        case NPC_CHAT_FOLLOW: {
            const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
            if( npcselect < 0 ) {
                return;
            }
            if( npcselect == guard_count ) {
                for( npc *them : guards ) {
                    talk_function::stop_guard( *them );
                }
                yell_msg = _( "Everyone follow me!" );
            } else {
                talk_function::stop_guard( *guards[npcselect] );
                yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
            }
            break;
        }
        case NPC_CHAT_AWAKE:
            for( npc *them : followers ) {
                talk_function::wake_up( *them );
            }
            yell_msg = _( "Stay awake!" );
            break;
        case NPC_CHAT_MOUNT:
            for( npc *them : followers ) {
                if( them->has_effect( effect_riding ) ) {
                    continue;
                }
                talk_function::find_mount( *them );
            }
            yell_msg = _( "Mount up!" );
            break;
        case NPC_CHAT_DISMOUNT:
            for( npc *them : followers ) {
                if( them->has_effect( effect_riding ) ) {
                    them->npc_dismount();
                }
            }
            yell_msg = _( "Dismount!" );
            break;
        case NPC_CHAT_DANGER:
            for( npc *them : followers ) {
                them->rules.set_danger_overrides();
            }
            yell_msg = _( "We're in danger.  Stay awake, stay close, don't go wandering off, "
                          "and don't open any doors." );
            break;
        case NPC_CHAT_CLEAR_OVERRIDES:
            for( npc *p : followers ) {
                talk_function::clear_overrides( *p );
            }
            yell_msg = _( "As you were." );
            break;
        case NPC_CHAT_ORDERS:
            npc_temp_orders_menu( followers );
            break;
        case NPC_CHAT_ANIMAL_VEHICLE_FOLLOW:
            assign_veh_to_follow();
            break;
        case NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW:
            tell_veh_stop_following();
            break;
        case NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW:
            tell_magic_veh_to_follow();
            break;
        case NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW:
            tell_magic_veh_stop_following();
            break;
        default:
            return;
    }
 
    if( !yell_msg.empty() ) {
        message = string_format( "\"%s\"", yell_msg );
    }
    if( !message.empty() ) {
        add_msg( _( "You yell %s" ), message );
        u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
    }
 
    u.moves -= 100;
}

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

check_mod_data()

bool game::check_mod_data	(	const std::vector< mod_id > &	opts,
		loading_ui &	ui
	)

Check if mods can be successfully loaded.

Parameters

opts	check specific mods (or all if unspecified)

Returns

whether all mods were successfully loaded

Definition at line 342 of file game.cpp.

{
    auto &tree = world_generator->get_mod_manager().get_tree();
 
    // deduplicated list of mods to check
    std::set<mod_id> check( opts.begin(), opts.end() );
 
    // if no specific mods specified check all non-obsolete mods
    if( check.empty() ) {
        for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
            if( !e->obsolete ) {
                check.emplace( e );
            }
        }
    }
 
    if( check.empty() ) {
        world_generator->set_active_world( nullptr );
        world_generator->init();
        const std::vector<mod_id> mods_empty;
        WORLDPTR test_world = world_generator->make_new_world( mods_empty );
        world_generator->set_active_world( test_world );
 
        // if no loadable mods then test core data only
        try {
            load_core_data( ui );
            DynamicDataLoader::get_instance().finalize_loaded_data( ui );
        } catch( const std::exception &err ) {
            std::cerr << "Error loading data from json: " << err.what() << std::endl;
        }
 
        std::string world_name = world_generator->active_world->world_name;
        world_generator->delete_world( world_name, true );
 
        MAPBUFFER.reset();
        overmap_buffer.clear();
    }
 
    for( const auto &e : check ) {
        world_generator->set_active_world( nullptr );
        world_generator->init();
        const std::vector<mod_id> mods_empty;
        WORLDPTR test_world = world_generator->make_new_world( mods_empty );
        if( !test_world ) {
            std::cerr << "Failed to generate test world." << std::endl;
            return false;
        }
        world_generator->set_active_world( test_world );
 
        if( !e.is_valid() ) {
            std::cerr << "Unknown mod: " << e.str() << std::endl;
            return false;
        }
 
        const MOD_INFORMATION &mod = *e;
 
        if( !tree.is_available( mod.ident ) ) {
            std::cerr << "Missing dependencies: " << mod.name() << "\n"
                      << tree.get_node( mod.ident )->s_errors() << std::endl;
            return false;
        }
 
        std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
 
        try {
            load_core_data( ui );
 
            // Load any dependencies
            for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
                load_data_from_dir( dep->path, dep->ident.str(), ui );
            }
 
            // Load mod itself
            load_data_from_dir( mod.path, mod.ident.str(), ui );
            DynamicDataLoader::get_instance().finalize_loaded_data( ui );
        } catch( const std::exception &err ) {
            std::cerr << "Error loading data: " << err.what() << std::endl;
        }
 
        std::string world_name = world_generator->active_world->world_name;
        world_generator->delete_world( world_name, true );
 
        MAPBUFFER.reset();
        overmap_buffer.clear();
    }
    return true;
}

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

check_near_zone()

bool game::check_near_zone	(	const zone_type_id &	type,
		const tripoint &	where
	)		const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6285 of file game.cpp.

{
    return zone_manager::get_manager().has_near( type, m.getabs( where ) );
}

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

check_safe_mode_allowed()

bool game::check_safe_mode_allowed

(

bool

repeat_safe_mode_warnings = true

)

Check whether movement is allowed according to safe mode settings.

Returns

true if the movement is allowed, otherwise false.

Definition at line 9112 of file game.cpp.

{
    if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
        // Already warned player since safe_mode_warning_logged is set.
        return false;
    }
 
    std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
    if( !msg_ignore.empty() ) {
        std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
        // Operate on a wide-char basis to prevent corrupted multi-byte string
        msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
        msg_ignore = wstr_to_utf8( msg_ignore_wide );
    }
 
    if( u.has_effect( effect_laserlocked ) ) {
        // Automatic and mandatory safemode.  Make BLOODY sure the player notices!
        if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
            add_msg( game_message_params{ m_warning, gmf_bypass_cooldown },
                     _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
        } else {
            add_msg( game_message_params{ m_warning, gmf_bypass_cooldown },
                     _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
        }
        safe_mode_warning_logged = true;
        return false;
    }
    if( safe_mode != SAFE_MODE_STOP ) {
        return true;
    }
    // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
    if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
        return true;
    }
    // Monsters around and we don't want to run
    std::string spotted_creature_name;
    const monster_visible_info &mon_visible = u.get_mon_visible();
    const auto &new_seen_mon = mon_visible.new_seen_mon;
 
    if( new_seen_mon.empty() ) {
        // naming consistent with code in game::mon_info
        spotted_creature_name = _( "a survivor" );
        get_safemode().lastmon_whitelist = get_safemode().npc_type_name();
    } else {
        spotted_creature_name = new_seen_mon.back()->name();
        get_safemode().lastmon_whitelist = spotted_creature_name;
    }
 
    std::string whitelist;
    if( !get_safemode().empty() ) {
        whitelist = string_format( _( " or %s to whitelist the monster" ),
                                   press_x( ACTION_WHITELIST_ENEMY ) );
    }
 
    const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
    add_msg( game_message_params{ m_warning, gmf_bypass_cooldown },
             _( "Spotted %1$s--safe mode is on!  (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
             spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
    safe_mode_warning_logged = true;
    return false;
}

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

check_zone()

bool game::check_zone	(	const zone_type_id &	type,
		const tripoint &	where
	)		const

Definition at line 6280 of file game.cpp.

{
    return zone_manager::get_manager().has( type, m.getabs( where ) );
}

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

cleanup_at_end()

bool game::cleanup_at_end

(

)

Definition at line 1027 of file game.cpp.

{
    if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
        // Put (non-hallucinations) into the overmap so they are not lost.
        for( monster &critter : all_monsters() ) {
            despawn_monster( critter );
        }
        // Reset NPC factions and disposition
        reset_npc_dispositions();
        // Save the factions', missions and set the NPC's overmap coordinates
        // Npcs are saved in the overmap.
        save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
        // save artifacts.
        save_artifacts();
 
        // and the overmap, and the local map.
        save_maps(); //Omap also contains the npcs who need to be saved.
    }
 
    if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
        std::vector<std::string> vRip;
 
        int iMaxWidth = 0;
        int iNameLine = 0;
        int iInfoLine = 0;
 
        if( u.has_amount( itype_holybook_bible1, 1 ) || u.has_amount( itype_holybook_bible2, 1 ) ||
            u.has_amount( itype_holybook_bible3, 1 ) ) {
            if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
                vRip.emplace_back( "               _______  ___" );
                vRip.emplace_back( "              <       `/   |" );
                vRip.emplace_back( "               >  _     _ (" );
                vRip.emplace_back( "              |  |_) | |_) |" );
                vRip.emplace_back( "              |  | \\ | |   |" );
                vRip.emplace_back( "   ______.__%_|            |_________  __" );
                vRip.emplace_back( " _/                                  \\|  |" );
                iNameLine = vRip.size();
                vRip.emplace_back( "|                                        <" );
                vRip.emplace_back( "|                                        |" );
                iMaxWidth = utf8_width( vRip.back() );
                vRip.emplace_back( "|                                        |" );
                vRip.emplace_back( "|_____.-._____              __/|_________|" );
                vRip.emplace_back( "              |            |" );
                iInfoLine = vRip.size();
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |           <" );
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |   _        |" );
                vRip.emplace_back( "              |__/         |" );
                vRip.emplace_back( "             % / `--.      |%" );
                vRip.emplace_back( "         * .%%|          -< @%%%" ); // NOLINT(cata-text-style)
                vRip.emplace_back( "         `\\%`@|            |@@%@%%" );
                vRip.emplace_back( "       .%%%@@@|%     `   % @@@%%@%%%%" );
                vRip.emplace_back( "  _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
 
            } else {
                vRip.emplace_back( "               _______  ___" );
                vRip.emplace_back( "              |       \\/   |" );
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |            |" );
                iInfoLine = vRip.size();
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |            |" );
                vRip.emplace_back( "              |           <" );
                vRip.emplace_back( "              |   _        |" );
                vRip.emplace_back( "              |__/         |" );
                vRip.emplace_back( "   ______.__%_|            |__________  _" );
                vRip.emplace_back( " _/                                   \\| \\" );
                iNameLine = vRip.size();
                vRip.emplace_back( "|                                         <" );
                vRip.emplace_back( "|                                         |" );
                iMaxWidth = utf8_width( vRip.back() );
                vRip.emplace_back( "|                                         |" );
                vRip.emplace_back( "|_____.-._______            __/|__________|" );
                vRip.emplace_back( "             % / `_-.   _  |%" );
                vRip.emplace_back( "         * .%%|  |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
                vRip.emplace_back( "         `\\%`@|  | \\ | |   |@@%@%%" );
                vRip.emplace_back( "       .%%%@@@|%     `   % @@@%%@%%%%" );
                vRip.emplace_back( "  _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
            }
        } else {
            vRip.emplace_back( R"(           _________  ____           )" );
            vRip.emplace_back( R"(         _/         `/    \_         )" );
            vRip.emplace_back( R"(       _/      _     _      \_.      )" );
            vRip.emplace_back( R"(     _%\      |_) | |_)       \_     )" );
            vRip.emplace_back( R"(   _/ \/      | \ | |           \_   )" );
            vRip.emplace_back( R"( _/                               \_ )" );
            vRip.emplace_back( R"(|                                   |)" );
            iNameLine = vRip.size();
            vRip.emplace_back( R"( )                                 < )" );
            vRip.emplace_back( R"(|                                   |)" );
            vRip.emplace_back( R"(|                                   |)" );
            vRip.emplace_back( R"(|   _                               |)" );
            vRip.emplace_back( R"(|__/                                |)" );
            iMaxWidth = utf8_width( vRip.back() );
            vRip.emplace_back( R"( / `--.                             |)" );
            vRip.emplace_back( R"(|                                  ( )" );
            iInfoLine = vRip.size();
            vRip.emplace_back( R"(|                                   |)" );
            vRip.emplace_back( R"(|                                   |)" );
            vRip.emplace_back( R"(|     %                         .   |)" );
            vRip.emplace_back( R"(|  @`                            %% |)" );
            vRip.emplace_back( R"(| %@%@%\                *      %`%@%|)" );
            vRip.emplace_back( R"(%%@@@.%@%\%%            `\  %%.%%@@%@)" );
            vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
        }
 
        const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
        const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
 
        catacurses::window w_rip = catacurses::newwin( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH,
                                   point( iOffsetX, iOffsetY ) );
        draw_border( w_rip );
 
        sfx::do_player_death_hurt( g->u, true );
        sfx::fade_audio_group( sfx::group::weather, 2000 );
        sfx::fade_audio_group( sfx::group::time_of_day, 2000 );
        sfx::fade_audio_group( sfx::group::context_themes, 2000 );
        sfx::fade_audio_group( sfx::group::fatigue, 2000 );
 
        for( size_t iY = 0; iY < vRip.size(); ++iY ) {
            size_t iX = 0;
            const char *str = vRip[iY].data();
            for( int slen = vRip[iY].size(); slen > 0; ) {
                const uint32_t cTemp = UTF8_getch( &str, &slen );
                if( cTemp != U' ' ) {
                    nc_color ncColor = c_light_gray;
 
                    if( cTemp == U'%' ) {
                        ncColor = c_green;
 
                    } else if( cTemp == U'_' || cTemp == U'|' ) {
                        ncColor = c_white;
 
                    } else if( cTemp == U'@' ) {
                        ncColor = c_brown;
 
                    } else if( cTemp == U'*' ) {
                        ncColor = c_red;
                    }
 
                    mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
                              cTemp );
                }
                iX += mk_wcwidth( cTemp );
            }
        }
 
        std::string sTemp;
 
        center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
 
        const time_duration survived = calendar::turn - calendar::start_of_cataclysm;
        const int minutes = to_minutes<int>( survived ) % 60;
        const int hours = to_hours<int>( survived ) % 24;
        const int days = to_days<int>( survived );
 
        if( days > 0 ) {
            sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
        } else if( hours > 0 ) {
            sTemp = string_format( "%dh %dm", hours, minutes );
        } else {
            sTemp = string_format( "%dm", minutes );
        }
 
        center_print( w_rip, iInfoLine++, c_white, sTemp );
 
        const int iTotalKills = get_kill_tracker().monster_kill_count();
 
        sTemp = _( "Kills:" );
        mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
                   ( sTemp + " " ) );
        wprintz( w_rip, c_magenta, "%d", iTotalKills );
 
        sTemp = _( "In memory of:" );
        mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
                   c_light_gray,
                   sTemp );
 
        sTemp = u.name;
        mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
                   sTemp );
 
        sTemp = _( "Last Words:" );
        mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
                   c_light_gray,
                   sTemp );
 
        int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
        std::string sLastWords = string_input_popup()
                                 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
                                 .max_length( iMaxWidth - 4 - 1 )
                                 .query_string();
        death_screen();
        const bool is_suicide = uquit == QUIT_SUICIDE;
        events().send<event_type::game_over>( is_suicide, sLastWords );
        // Struck the save_player_data here to forestall Weirdness
        std::string char_filename = generate_memorial_filename( u.name );
        move_save_to_graveyard( char_filename );
        write_memorial_file( char_filename, sLastWords );
        memorial().clear();
        std::vector<std::string> characters = list_active_characters();
        // remove current player from the active characters list, as they are dead
        std::vector<std::string>::iterator curchar = std::find( characters.begin(),
                characters.end(), u.name );
        if( curchar != characters.end() ) {
            characters.erase( curchar );
        }
 
        if( characters.empty() ) {
            bool queryDelete = false;
            bool queryReset = false;
 
            if( get_option<std::string>( "WORLD_END" ) == "query" ) {
                bool decided = false;
                std::string buffer = _( "Warning: NPC interactions and some other global flags "
                                        "will not all reset when starting a new character in an "
                                        "already-played world.  This can lead to some strange "
                                        "behavior.\n\n"
                                        "Are you sure you wish to keep this world?"
                                      );
 
                while( !decided ) {
                    uilist smenu;
                    smenu.allow_cancel = false;
                    smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
                    smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
                    smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
                    smenu.query();
 
                    switch( smenu.ret ) {
                        case 0:
                            queryReset = true;
                            decided = true;
                            break;
                        case 1:
                            queryDelete = true;
                            decided = true;
                            break;
                        case 2:
                            decided = query_yn( buffer );
                            break;
                    }
                }
            }
 
            if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
                world_generator->delete_world( world_generator->active_world->world_name, true );
 
            } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
                world_generator->delete_world( world_generator->active_world->world_name, false );
            }
        } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
            std::string tmpmessage;
            for( auto &character : characters ) {
                tmpmessage += "\n  ";
                tmpmessage += character;
            }
            popup( _( "World retained.  Characters remaining:%s" ), tmpmessage );
        }
        if( gamemode ) {
            gamemode = std::make_unique<special_game>(); // null gamemode or something..
        }
    }
 
    //Reset any offset due to driving
    set_driving_view_offset( point_zero );
 
    //clear all sound channels
    sfx::fade_audio_channel( sfx::channel::any, 300 );
    sfx::fade_audio_group( sfx::group::weather, 300 );
    sfx::fade_audio_group( sfx::group::time_of_day, 300 );
    sfx::fade_audio_group( sfx::group::context_themes, 300 );
    sfx::fade_audio_group( sfx::group::fatigue, 300 );
 
    MAPBUFFER.reset();
    overmap_buffer.clear();
 
#if defined(__ANDROID__)
    quick_shortcuts_map.clear();
#endif
    return true;
}

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

cleanup_dead()

void game::cleanup_dead

(

)

Definition at line 4361 of file game.cpp.

{
    // Dead monsters need to stay in the tracker until everything else that needs to die does so
    // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
    bool monster_is_dead = critter_tracker->kill_marked_for_death();
 
    bool npc_is_dead = false;
    // can't use all_npcs as that does not include dead ones
    for( const auto &n : active_npc ) {
        if( n->is_dead() ) {
            n->die( nullptr ); // make sure this has been called to create corpses etc.
            npc_is_dead = true;
        }
    }
 
    if( monster_is_dead ) {
        // From here on, pointers to creatures get invalidated as dead creatures get removed.
        critter_tracker->remove_dead();
    }
 
    if( npc_is_dead ) {
        for( auto it = active_npc.begin(); it != active_npc.end(); ) {
            if( ( *it )->is_dead() ) {
                remove_npc_follower( ( *it )->getID() );
                overmap_buffer.remove_npc( ( *it )->getID() );
                it = active_npc.erase( it );
            } else {
                it++;
            }
        }
    }
 
    critter_died = false;
}

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

clear_zombies()

void game::clear_zombies

(

)

Redirects to the creature_tracker clear() function.

Definition at line 5027 of file game.cpp.

{
    critter_tracker->clear();
}

References critter_tracker.

Referenced by setup().

control_vehicle()

void game::control_vehicle ( )

private

Definition at line 5441 of file game.cpp.

{
    static const itype_id fuel_type_animal( "animal" );
    int veh_part = -1;
    vehicle *veh = remoteveh();
    if( veh == nullptr ) {
        if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
            veh = &vp->vehicle();
            veh_part = vp->part_index();
        }
    }
    if( veh != nullptr && veh->player_in_control( u ) &&
        veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
        veh->use_controls( u.pos() );
    } else if( veh && veh->player_in_control( u ) &&
               veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
        u.controlling_vehicle = false;
        add_msg( m_info, _( "You let go of the reins." ) );
    } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
                        ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
                          veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
               u.in_vehicle ) {
        if( u.has_trait( trait_WAYFARER ) ) {
            add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
            return;
        }
        if( !veh->interact_vehicle_locked() ) {
            veh->handle_potential_theft( dynamic_cast<player &>( u ) );
            return;
        }
        if( veh->engine_on ) {
            if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
                return;
            }
            u.controlling_vehicle = true;
            add_msg( _( "You take control of the %s." ), veh->name );
        } else {
            if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
                return;
            }
            veh->start_engines( true );
        }
    } else {    // Start looking for nearby vehicle controls.
        int num_valid_controls = 0;
        cata::optional<tripoint> vehicle_position;
        cata::optional<vpart_reference> vehicle_controls;
        for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
            if( const optional_vpart_position vp = m.veh_at( elem ) ) {
                const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
                if( controls ) {
                    num_valid_controls++;
                    vehicle_position = elem;
                    vehicle_controls = controls;
                }
            }
        }
        if( num_valid_controls < 1 ) {
            add_msg( _( "No vehicle controls found." ) );
            return;
        } else if( num_valid_controls > 1 ) {
            vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
            if( !vehicle_position ) {
                return;
            }
            const optional_vpart_position vp = m.veh_at( *vehicle_position );
            if( vp ) {
                vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
                if( !vehicle_controls ) {
                    add_msg( _( "The vehicle doesn't have controls there." ) );
                    return;
                }
            } else {
                add_msg( _( "No vehicle there." ) );
                return;
            }
        }
        // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
        if( vehicle_controls ) {
            veh = &vehicle_controls->vehicle();
            if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
                return;
            }
            veh->use_controls( *vehicle_position );
            //May be folded up (destroyed), so need to re-get it
            veh = g->remoteveh();
        }
    }
    if( veh ) {
        // If we reached here, we gained control of a vehicle.
        // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
        for( const tripoint &target : veh->get_points() ) {
            u.clear_memorized_tile( m.getabs( target ) );
        }
        veh->is_following = false;
        veh->is_patrolling = false;
        veh->autopilot_on = false;
        veh->is_autodriving = false;
    }
}

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor

(

)

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3272 of file game.cpp.

{
    shared_ptr_fast<ui_adaptor> ui = main_ui_adaptor.lock();
    if( !ui ) {
        main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
        ui->on_redraw( []( const ui_adaptor & ) {
            g->draw();
        } );
        ui->on_screen_resize( [this]( ui_adaptor & ui ) {
            // remove some space for the sidebar, this is the maximal space
            // (using standard font) that the terrain window can have
            const int sidebar_left = panel_manager::get_manager().get_width_left();
            const int sidebar_right = panel_manager::get_manager().get_width_right();
 
            TERRAIN_WINDOW_HEIGHT = TERMY;
            TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
            TERRAIN_WINDOW_TERM_WIDTH = TERRAIN_WINDOW_WIDTH;
            TERRAIN_WINDOW_TERM_HEIGHT = TERRAIN_WINDOW_HEIGHT;
 
            /**
             * In tiles mode w_terrain can have a different font (with a different
             * tile dimension) or can be drawn by cata_tiles which uses tiles that again
             * might have a different dimension then the normal font used everywhere else.
             *
             * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
             * be displayed in w_terrain (using it's specific tile dimension), not
             * including partially drawn squares at the right/bottom. You should
             * use it whenever you want to draw specific squares in that window or to
             * determine whether a specific square is draw on screen (or outside the screen
             * and needs scrolling).
             *
             * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
             * w_terrain in the standard font dimension (the font that everything else uses).
             * You usually don't have to use it, expect for positioning of windows,
             * because the window positions use the standard font dimension.
             *
             * The code here calculates size available for w_terrain, caps it at
             * max_view_size (the maximal view range than any character can have at
             * any time).
             * It is stored in TERRAIN_WINDOW_*.
             */
            to_map_font_dimension( TERRAIN_WINDOW_WIDTH, TERRAIN_WINDOW_HEIGHT );
 
            // Position of the player in the terrain window, it is always in the center
            POSX = TERRAIN_WINDOW_WIDTH / 2;
            POSY = TERRAIN_WINDOW_HEIGHT / 2;
 
            w_terrain = w_terrain_ptr = catacurses::newwin( TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_WIDTH,
                                        point( sidebar_left, 0 ) );
 
            // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
            w_minimap = w_minimap_ptr = catacurses::newwin( MINIMAP_HEIGHT, MINIMAP_WIDTH, point_zero );
 
            // need to init in order to avoid crash. gets updated by the panel code.
            w_pixel_minimap = catacurses::newwin( 1, 1, point_zero );
 
            ui.position_from_window( catacurses::stdscr );
        } );
        ui->mark_resize();
    }
    return ui;
}

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

create_starting_npcs()

void game::create_starting_npcs ( )

private

Definition at line 970 of file game.cpp.

{
    if( !get_option<bool>( "STATIC_NPC" ) ||
        get_option<std::string>( "STARTING_NPC" ) == "never" ) {
        return; //Do not generate a starting npc.
    }
 
    //We don't want more than one starting npc per starting location
    const int radius = 1;
    if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
        return; //There is already an NPC in this starting location
    }
 
    shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
    tmp->normalize();
    tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
    tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
    overmap_buffer.insert_npc( tmp );
    tmp->form_opinion( u );
    tmp->set_attitude( NPCATT_NULL );
    //This sets the NPC mission. This NPC remains in the starting location.
    tmp->mission = NPC_MISSION_SHELTER;
    tmp->chatbin.first_topic = "TALK_SHELTER";
    tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
    tmp->set_fac( faction_id( "no_faction" ) );
    //One random starting NPC mission
    tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
                          tmp->getID() ) );
}

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

critter_at() [1/2]

template<typename T >

T * game::critter_at	(	const tripoint &	p,
		bool	allow_hallucination = false
	)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters

allow_hallucination

Whether to return monsters that are actually hallucinations.

Definition at line 4832 of file game.cpp.

{
    if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
        if( !allow_hallucination && mon_ptr->is_hallucination() ) {
            return nullptr;
        }
        // if we wanted to check for an NPC / player / avatar,
        // there is sometimes a monster AND an NPC/player there at the same time.
        // because the NPC/player etc may be riding that monster.
        // so only return the monster if we were actually looking for a monster.
        // otherwise, keep looking for the rider.
        // critter_at<creature> or critter_at() with no template will still default to returning monster first,
        // which is ok for the occasions where that happens.
        if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
                std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
                std::is_same<T, const Creature>::value ) ) {
            return dynamic_cast<T *>( mon_ptr.get() );
        }
    }
    if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
        if( p == u.pos() ) {
            return dynamic_cast<T *>( &u );
        }
    }
    for( auto &cur_npc : active_npc ) {
        if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
            return dynamic_cast<T *>( cur_npc.get() );
        }
    }
    return nullptr;
}

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

critter_at() [2/2]

template<typename T >

const T * game::critter_at	(	const tripoint &	p,
		bool	allow_hallucination = false
	)		const

Definition at line 4865 of file game.cpp.

{
    return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
}

critter_by_id()

template<typename T >

template Creature * game::critter_by_id< Creature >

(

const character_id &

id

)

Returns

The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4911 of file game.cpp.

{
    if( id == u.getID() ) {
        // player is always alive, therefore no is-dead check
        return dynamic_cast<T *>( &u );
    }
    return find_npc( id );
}

References find_npc(), Character::getID(), and u.

death_screen()

void game::death_screen ( )

private

Definition at line 2722 of file game.cpp.

{
    gamemode->game_over();
    Messages::display_messages();
    show_scores_ui( *achievements_tracker_ptr, stats(), get_kill_tracker() );
    disp_NPC_epilogues();
    follower_ids.clear();
    display_faction_epilogues();
}

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

despawn_monster()

void game::despawn_monster

(

monster &

critter

)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11532 of file game.cpp.

{
    if( !critter.is_hallucination() ) {
        // hallucinations aren't stored, they come and go as they like,
        overmap_buffer.despawn_monster( critter );
    }
 
    critter.on_unload();
    remove_zombie( critter );
    // simulate it being dead so further processing of it (e.g. in monmove) will yield
    critter.set_hp( 0 );
}

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

disable_robot()

bool game::disable_robot

(

const tripoint &

p

)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns

true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 9180 of file game.cpp.

{
    monster *const mon_ptr = critter_at<monster>( p );
    if( !mon_ptr ) {
        return false;
    }
    monster &critter = *mon_ptr;
    if( critter.friendly == 0 || critter.has_flag( MF_RIDEABLE_MECH ) ||
        ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
        // Can only disable / reprogram friendly monsters
        return false;
    }
    const auto mid = critter.type->id;
    const auto mon_item_id = critter.type->revert_to_itype;
    if( !mon_item_id.is_empty() &&
        query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
 
        u.moves -= 100;
        m.add_item_or_charges( p, critter.to_item() );
        if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
            for( auto &ammodef : critter.ammo ) {
                if( ammodef.second > 0 ) {
                    m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
                }
            }
        }
        remove_zombie( critter );
        return true;
    }
    // Manhacks are special, they have their own menu here.
    if( mid == mon_manhack ) {
        int choice = UILIST_CANCEL;
        if( critter.has_effect( effect_docile ) ) {
            choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
        } else {
            choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
        }
        switch( choice ) {
            case 0:
                if( critter.has_effect( effect_docile ) ) {
                    critter.remove_effect( effect_docile );
                    if( one_in( 3 ) ) {
                        add_msg( _( "The %s hovers momentarily as it surveys the area." ),
                                 critter.name() );
                    }
                } else {
                    critter.add_effect( effect_docile, 1_turns, num_bp );
                    if( one_in( 3 ) ) {
                        add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
                                 critter.name() );
                    }
                }
                u.moves -= 100;
                return true;
            default:
                break;
        }
    }
    return false;
}

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )

private

Definition at line 3159 of file game.cpp.

{
    // TODO: This search needs to be expanded to all NPCs
    for( auto elem : follower_ids ) {
        shared_ptr_fast<npc> guy = overmap_buffer.find_npc( elem );
        if( !guy ) {
            continue;
        }
        const auto new_win = []() {
            return catacurses::newwin( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH,
                                       point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
                                              std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
        };
        scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
    }
}

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

disp_NPCs()

void game::disp_NPCs

(

)

Definition at line 3210 of file game.cpp.

{
    const tripoint_abs_omt ppos = u.global_omt_location();
    const tripoint &lpos = u.pos();
    std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
    std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
 
    catacurses::window w;
    ui_adaptor ui;
    ui.on_screen_resize( [&]( ui_adaptor & ui ) {
        w = catacurses::newwin( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH,
                                point( TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0,
                                       TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
        ui.position_from_window( w );
    } );
    ui.mark_resize();
    ui.on_redraw( [&]( const ui_adaptor & ) {
        werase( w );
        mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
        // NOLINTNEXTLINE(cata-use-named-point-constants)
        mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
        size_t i;
        for( i = 0; i < 20 && i < npcs.size(); i++ ) {
            const tripoint_abs_omt apos = npcs[i]->global_omt_location();
            mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
                       apos.to_string() );
        }
        for( const monster &m : all_monsters() ) {
            mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
                       m.posx(), m.posy(), m.posz() );
            ++i;
        }
        wnoutrefresh( w );
    } );
 
    input_context ctxt( "DISP_NPCS" );
    ctxt.register_action( "CONFIRM" );
    ctxt.register_action( "QUIT" );
    ctxt.register_action( "HELP_KEYBINDINGS" );
    bool stop = false;
    while( !stop ) {
        ui_manager::redraw();
        const std::string action = ctxt.handle_input();
        if( action == "CONFIRM" || action == "QUIT" ) {
            stop = true;
        }
    }
}

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

display_faction_epilogues()

void game::display_faction_epilogues ( )

private

Definition at line 3176 of file game.cpp.

{
    for( const auto &elem : faction_manager_ptr->all() ) {
        if( elem.second.known_by_u ) {
            const std::vector<std::string> epilogue = elem.second.epilogue();
            if( !epilogue.empty() ) {
                const auto new_win = []() {
                    return catacurses::newwin( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH,
                                               point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
                                                      std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
                };
                scrollable_text( new_win, elem.second.name,
                                 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
                []( const std::string & lhs, const std::string & rhs ) -> std::string {
                    return lhs + "\n" + rhs;
                } ) );
            }
        }
    }
}

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

display_lighting()

void game::display_lighting ( )

private

Definition at line 11744 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_LIGHTING );
        if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
            return;
        }
        uilist lighting_menu;
        std::vector<std::string> lighting_menu_strings{
            "Global lighting conditions"
        };
 
        int count = 0;
        for( const auto &menu_str : lighting_menu_strings ) {
            lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
        }
 
        lighting_menu.w_y_setup = 0;
        lighting_menu.query();
        if( ( lighting_menu.ret >= 0 ) &&
            ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
            g->displaying_lighting_condition = lighting_menu.ret;
        }
    }
}

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

display_overlay_state()

bool game::display_overlay_state

(

action_id

action

)

Definition at line 11635 of file game.cpp.

{
    return displaying_overlays && *displaying_overlays == action;
}

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

display_radiation()

void game::display_radiation ( )

private

Definition at line 11770 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_RADIATION );
    }
}

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

display_scent()

void game::display_scent ( )

private

Definition at line 11649 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_SCENT );
    } else {
        int div;
        bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
        if( !got_value || div < 1 ) {
            add_msg( _( "Never mind." ) );
            return;
        }
        shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
            scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
        } );
        g->add_draw_callback( scent_cb );
 
        ui_manager::redraw();
        inp_mngr.wait_for_any_key();
    }
}

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

display_temperature()

void game::display_temperature ( )

private

Definition at line 11670 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_TEMPERATURE );
    }
}

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

display_toggle_overlay()

void game::display_toggle_overlay

(

action_id

action

)

Definition at line 11640 of file game.cpp.

{
    if( display_overlay_state( action ) ) {
        displaying_overlays.reset();
    } else {
        displaying_overlays = action;
    }
}

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

display_transparency()

void game::display_transparency ( )

private

Definition at line 11777 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_TRANSPARENCY );
    }
}

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

display_vehicle_ai()

void game::display_vehicle_ai ( )

private

Definition at line 11677 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_VEHICLE_AI );
    }
}

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

display_visibility()

void game::display_visibility ( )

private

Definition at line 11684 of file game.cpp.

{
    if( use_tiles ) {
        display_toggle_overlay( ACTION_DISPLAY_VISIBILITY );
        if( display_overlay_state( ACTION_DISPLAY_VISIBILITY ) ) {
            std::vector< tripoint > locations;
            uilist creature_menu;
            int num_creatures = 0;
            creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
            locations.emplace_back( g->u.pos() ); // add player first.
            for( const Creature &critter : g->all_creatures() ) {
                if( critter.is_player() ) {
                    continue;
                }
                creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
                locations.emplace_back( critter.pos() );
            }
 
            pointmenu_cb callback( locations );
            creature_menu.callback = &callback;
            creature_menu.w_y_setup = 0;
            creature_menu.query();
            if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
                Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
                displaying_visibility_creature = creature;
            }
        } else {
            displaying_visibility_creature = nullptr;
        }
    }
}

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

do_turn()

bool game::do_turn

(

)

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1433 of file game.cpp.

{
    if( is_game_over() ) {
        return cleanup_at_end();
    }
    // Actual stuff
    if( new_game ) {
        new_game = false;
    } else {
        gamemode->per_turn();
        calendar::turn += 1_turns;
    }
 
    // starting a new turn, clear out temperature cache
    weather_manager &weather = get_weather();
    weather.clear_temp_cache();
 
    if( npcs_dirty ) {
        load_npcs();
    }
 
    timed_events.process();
    mission::process_all();
    // If controlling a vehicle that is owned by someone else
    if( u.in_vehicle && u.controlling_vehicle ) {
        vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
        if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
            veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
        }
    }
    // If riding a horse - chance to spook
    if( u.is_mounted() ) {
        u.check_mount_is_spooked();
    }
    if( calendar::once_every( 1_days ) ) {
        overmap_buffer.process_mongroups();
    }
 
    // Move hordes every 2.5 min
    if( calendar::once_every( time_duration::from_minutes( 2.5 ) ) ) {
        overmap_buffer.move_hordes();
        // Hordes that reached the reality bubble need to spawn,
        // make them spawn in invisible areas only.
        m.spawn_monsters( false );
    }
 
    debug_hour_timer.print_time();
 
    u.update_body();
 
    // Auto-save if autosave is enabled
    if( get_option<bool>( "AUTOSAVE" ) &&
        calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
        !u.is_dead_state() ) {
        autosave();
    }
 
    weather.update_weather();
    reset_light_level();
 
    perhaps_add_random_npc();
    process_voluntary_act_interrupt();
    process_activity();
    // Process NPC sound events before they move or they hear themselves talking
    for( npc &guy : all_npcs() ) {
        if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
            sounds::process_sound_markers( &guy );
        }
    }
 
    // Process sound events into sound markers for display to the player.
    sounds::process_sound_markers( &u );
 
    if( u.is_deaf() ) {
        sfx::do_hearing_loss();
    }
 
    if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
        if( u.moves > 0 || uquit == QUIT_WATCH ) {
            while( u.moves > 0 || uquit == QUIT_WATCH ) {
                cleanup_dead();
                mon_info_update();
                // Process any new sounds the player caused during their turn.
                for( npc &guy : all_npcs() ) {
                    if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
                        sounds::process_sound_markers( &guy );
                    }
                }
                sounds::process_sound_markers( &u );
                if( !u.activity && !u.has_distant_destination() && uquit != QUIT_WATCH && wait_popup ) {
                    wait_popup.reset();
                    ui_manager::redraw();
                }
 
                if( queue_screenshot ) {
                    invalidate_main_ui_adaptor();
                    ui_manager::redraw();
                    take_screenshot();
                    queue_screenshot = false;
                }
 
                if( handle_action() ) {
                    ++moves_since_last_save;
                    u.action_taken();
                }
 
                if( is_game_over() ) {
                    return cleanup_at_end();
                }
 
                if( uquit == QUIT_WATCH ) {
                    break;
                }
                if( u.activity ) {
                    process_activity();
                }
            }
            // Reset displayed sound markers now that the turn is over.
            // We only want this to happen if the player had a chance to examine the sounds.
            sounds::reset_markers();
        }
    }
 
    if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
        // Still have a view offset, but might not be driving anymore,
        // or the option has been deactivated,
        // might also happen when someone dives from a moving car.
        // or when using the handbrake.
        vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
        calc_driving_offset( veh );
    }
 
    // No-scent debug mutation has to be processed here or else it takes time to start working
    if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
        !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
        scent.set( u.pos(), u.scent, u.get_type_of_scent() );
        overmap_buffer.set_scent( u.global_omt_location(),  u.scent );
    }
    scent.update( u.pos(), m );
 
    // We need floor cache before checking falling 'n stuff
    m.build_floor_caches();
 
    m.process_falling();
    autopilot_vehicles();
    m.vehmove();
    m.process_fields();
    m.process_items();
    m.creature_in_field( u );
    grid_tracker_ptr->update( calendar::turn );
 
    // Apply sounds from previous turn to monster and NPC AI.
    sounds::process_sounds();
    // Update vision caches for monsters. If this turns out to be expensive,
    // consider a stripped down cache just for monsters.
    m.build_map_cache( get_levz(), true );
    monmove();
    if( calendar::once_every( 5_minutes ) ) {
        overmap_npc_move();
    }
    if( calendar::once_every( 10_seconds ) ) {
        for( const tripoint &elem : m.get_furn_field_locations() ) {
            const auto &furn = m.furn( elem ).obj();
            for( const emit_id &e : furn.emissions ) {
                g->m.emit_field( elem, e );
            }
        }
    }
    update_stair_monsters();
    mon_info_update();
    u.process_turn();
 
    explosion_handler::get_explosion_queue().execute();
    cleanup_dead();
 
    if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
        ui_manager::redraw();
        refresh_display();
    }
 
    if( get_levz() >= 0 && !u.is_underwater() ) {
        handle_weather_effects( weather.weather_id );
    }
 
    const bool player_is_sleeping = u.has_effect( effect_sleep );
    bool wait_redraw = false;
    std::string wait_message;
    time_duration wait_refresh_rate;
    if( player_is_sleeping ) {
        wait_redraw = true;
        wait_message = _( "Wait till you wake up…" );
        wait_refresh_rate = 30_minutes;
        if( calendar::once_every( 1_hours ) ) {
            add_artifact_dreams();
        }
    } else if( u.has_destination() ) {
        wait_redraw = true;
        wait_message = _( "Travelling…" );
        wait_refresh_rate = 15_turns;
    } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
        wait_redraw = true;
        wait_message = *progress;
        if( u.activity.id() == ACT_AUTODRIVE ) {
            wait_refresh_rate = 1_turns;
        } else {
            wait_refresh_rate = 5_minutes;
        }
    }
    if( wait_redraw ) {
        if( first_redraw_since_waiting_started ||
            calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
            if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
                ui_manager::redraw();
            }
 
            // Avoid redrawing the main UI every time due to invalidation
            ui_adaptor dummy( ui_adaptor::disable_uis_below {} );
            wait_popup = std::make_unique<static_popup>();
            wait_popup->on_top( true ).wait_message( "%s", wait_message );
            ui_manager::redraw();
            refresh_display();
            first_redraw_since_waiting_started = false;
        }
    } else {
        // Nothing to wait for now
        wait_popup.reset();
        first_redraw_since_waiting_started = true;
    }
 
    u.update_bodytemp( m, weather );
    u.update_body_wetness( get_weather().get_precise() );
    u.apply_wetness_morale( weather.temperature );
 
    if( calendar::once_every( 1_minutes ) ) {
        u.update_morale();
    }
 
    if( calendar::once_every( 9_turns ) ) {
        u.check_and_recover_morale();
    }
 
    if( !u.is_deaf() ) {
        sfx::remove_hearing_loss();
    }
    sfx::do_danger_music();
    sfx::do_vehicle_engine_sfx();
    sfx::do_vehicle_exterior_engine_sfx();
    sfx::do_fatigue();
 
    // reset player noise
    u.volume = 0;
 
    return false;
}

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), g, gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

draw()

void game::draw

(

)

Definition at line 3447 of file game.cpp.

{
    if( test_mode ) {
        return;
    }
 
    //temporary fix for updating visibility for minimap
    ter_view_p.z = ( u.pos() + u.view_offset ).z;
    m.build_map_cache( ter_view_p.z );
    m.update_visibility_cache( ter_view_p.z );
 
    werase( w_terrain );
    draw_ter();
    for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
        shared_ptr_fast<draw_callback_t> cb = it->lock();
        if( cb ) {
            ( *cb )();
            ++it;
        } else {
            it = draw_callbacks.erase( it );
        }
    }
    wnoutrefresh( w_terrain );
 
    draw_panels( true );
}

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

draw_below_override()

void game::draw_below_override	(	const tripoint &	p,
		bool	draw
	)

Definition at line 955 of file animation.cpp.

{
}

draw_bullet()

void game::draw_bullet	(	const tripoint &	t,
		int	i,
		const std::vector< tripoint > &	trajectory,
		char	bullet
	)

Definition at line 510 of file animation.cpp.

{
    draw_bullet_curses( m, t, bullet, &trajectory[i] );
}

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

draw_critter()

void game::draw_critter	(	const Creature &	critter,
		const tripoint &	center
	)

Definition at line 3570 of file game.cpp.

{
    draw_critter_internal( w_terrain, critter, center, false, m, u );
}

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

draw_critter_highlighted()

void game::draw_critter_highlighted	(	const Creature &	critter,
		const tripoint &	center
	)

Definition at line 3575 of file game.cpp.

{
    draw_critter_internal( w_terrain, critter, center, true, m, u );
}

References center, draw_critter_internal(), m, u, and w_terrain.

draw_cursor()

void game::draw_cursor

(

const tripoint &

p

)

Definition at line 716 of file animation.cpp.

{
    const tripoint rp = relative_view_pos( *this, p );
    mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
}

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

draw_field_override()

void game::draw_field_override	(	const tripoint &	p,
		const field_type_id &	id
	)

Definition at line 911 of file animation.cpp.

{
}

draw_furniture_override()

void game::draw_furniture_override	(	const tripoint &	p,
		const furn_id &	id
	)

Definition at line 872 of file animation.cpp.

{
}

draw_graffiti_override()

void game::draw_graffiti_override	(	const tripoint &	p,
		bool	has
	)

Definition at line 885 of file animation.cpp.

{
}

draw_highlight()

void game::draw_highlight

(

const tripoint &

p

)

Definition at line 729 of file animation.cpp.

{
    // Do nothing
}

draw_hit_mon()

void game::draw_hit_mon	(	const tripoint &	p,
		const monster &	m,
		bool	dead = false
	)

Definition at line 573 of file animation.cpp.

{
    draw_hit_mon_curses( p, m, u, dead );
}

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

draw_hit_player()

void game::draw_hit_player	(	const Character &	p,
		int	dam
	)

Definition at line 618 of file animation.cpp.

{
    draw_hit_player_curses( *this, p, dam );
}

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

draw_item_override()

void game::draw_item_override	(	const tripoint &	p,
		const itype_id &	id,
		const mtype_id &	mid,
		bool	hilite
	)

Definition at line 925 of file animation.cpp.

{
}

draw_line() [1/2]

void game::draw_line	(	const tripoint &	p,
		const std::vector< tripoint > &	points
	)

Definition at line 702 of file animation.cpp.

{
    draw_line_curses( *this, points );
}

References anonymous_namespace{animation.cpp}::draw_line_curses().

draw_line() [2/2]

void game::draw_line	(	const tripoint &	p,
		const tripoint &	center_point,
		const std::vector< tripoint > &	points,
		bool	noreveal = false
	)

Definition at line 669 of file animation.cpp.

{
    if( !u.sees( p ) ) {
        return;
    }
 
    draw_line_curses( *this, center, points, noreveal );
}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

draw_look_around_cursor()

void game::draw_look_around_cursor	(	const tripoint &	lp,
		const visibility_variables &	cache
	)

Definition at line 5948 of file game.cpp.

{
    if( !liveview.is_enabled() ) {
#if defined( TILES )
        if( is_draw_tiles_mode() ) {
            draw_cursor( lp );
            return;
        }
#endif
        const tripoint view_center = u.pos() + u.view_offset;
        visibility_type visibility = VIS_HIDDEN;
        const bool inbounds = m.inbounds( lp );
        if( inbounds ) {
            visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
        }
        if( visibility == VIS_CLEAR ) {
            const Creature *const creature = critter_at( lp, true );
            if( creature != nullptr && u.sees( *creature ) ) {
                creature->draw( w_terrain, view_center, true );
            } else {
                m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
            }
        } else {
            std::string visibility_indicator;
            nc_color visibility_indicator_color = c_white;
            switch( visibility ) {
                case VIS_CLEAR:
                    // Already handled by the outer if statement
                    break;
                case VIS_BOOMER:
                case VIS_BOOMER_DARK:
                    visibility_indicator = '#';
                    visibility_indicator_color = c_pink;
                    break;
                case VIS_DARK:
                    visibility_indicator = '#';
                    visibility_indicator_color = c_dark_gray;
                    break;
                case VIS_LIT:
                    visibility_indicator = '#';
                    visibility_indicator_color = c_light_gray;
                    break;
                case VIS_HIDDEN:
                    visibility_indicator = 'x';
                    visibility_indicator_color = c_white;
                    break;
            }
 
            const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
            mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
        }
    }
}

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

draw_minimap()

void game::draw_minimap ( )

private

Definition at line 3648 of file game.cpp.

{
 
    // Draw the box
    werase( w_minimap );
    draw_border( w_minimap );
 
    const tripoint_abs_omt curs = u.global_omt_location();
    const point_abs_omt curs2( curs.xy() );
    const tripoint_abs_omt targ = u.get_active_mission_target();
    bool drew_mission = targ == overmap::invalid_tripoint;
 
    for( int i = -2; i <= 2; i++ ) {
        for( int j = -2; j <= 2; j++ ) {
            const point_abs_omt om( curs2 + point( i, j ) );
            nc_color ter_color;
            tripoint_abs_omt omp( om, get_levz() );
            std::string ter_sym;
            const bool seen = overmap_buffer.seen( omp );
            const bool vehicle_here = overmap_buffer.has_vehicle( omp );
            if( overmap_buffer.has_note( omp ) ) {
 
                const std::string &note_text = overmap_buffer.note( omp );
 
                ter_color = c_yellow;
                ter_sym = "N";
 
                int symbolIndex = note_text.find( ':' );
                int colorIndex = note_text.find( ';' );
 
                bool symbolFirst = symbolIndex < colorIndex;
 
                if( colorIndex > -1 && symbolIndex > -1 ) {
                    if( symbolFirst ) {
                        if( colorIndex > 4 ) {
                            colorIndex = -1;
                        }
                        if( symbolIndex > 1 ) {
                            symbolIndex = -1;
                            colorIndex = -1;
                        }
                    } else {
                        if( symbolIndex > 4 ) {
                            symbolIndex = -1;
                        }
                        if( colorIndex > 2 ) {
                            colorIndex = -1;
                        }
                    }
                } else if( colorIndex > 2 ) {
                    colorIndex = -1;
                } else if( symbolIndex > 1 ) {
                    symbolIndex = -1;
                }
 
                if( symbolIndex > -1 ) {
                    int symbolStart = 0;
                    if( colorIndex > -1 && !symbolFirst ) {
                        symbolStart = colorIndex + 1;
                    }
                    ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
                }
 
                if( colorIndex > -1 ) {
 
                    int colorStart = 0;
 
                    if( symbolIndex > -1 && symbolFirst ) {
                        colorStart = symbolIndex + 1;
                    }
 
                    std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
 
                    if( sym.length() == 2 ) {
                        if( sym == "br" ) {
                            ter_color = c_brown;
                        } else if( sym == "lg" ) {
                            ter_color = c_light_gray;
                        } else if( sym == "dg" ) {
                            ter_color = c_dark_gray;
                        }
                    } else {
                        char colorID = sym.c_str()[0];
                        if( colorID == 'r' ) {
                            ter_color = c_light_red;
                        } else if( colorID == 'R' ) {
                            ter_color = c_red;
                        } else if( colorID == 'g' ) {
                            ter_color = c_light_green;
                        } else if( colorID == 'G' ) {
                            ter_color = c_green;
                        } else if( colorID == 'b' ) {
                            ter_color = c_light_blue;
                        } else if( colorID == 'B' ) {
                            ter_color = c_blue;
                        } else if( colorID == 'W' ) {
                            ter_color = c_white;
                        } else if( colorID == 'C' ) {
                            ter_color = c_cyan;
                        } else if( colorID == 'c' ) {
                            ter_color = c_light_cyan;
                        } else if( colorID == 'P' ) {
                            ter_color = c_pink;
                        } else if( colorID == 'm' ) {
                            ter_color = c_magenta;
                        }
                    }
                }
            } else if( !seen ) {
                ter_sym = " ";
                ter_color = c_black;
            } else if( vehicle_here ) {
                ter_color = c_cyan;
                ter_sym = "c";
            } else {
                const oter_id &cur_ter = overmap_buffer.ter( omp );
                ter_sym = cur_ter->get_symbol();
                if( overmap_buffer.is_explored( omp ) ) {
                    ter_color = c_dark_gray;
                } else {
                    ter_color = cur_ter->get_color();
                }
            }
            if( !drew_mission && targ.xy() == omp.xy() ) {
                // If there is a mission target, and it's not on the same
                // overmap terrain as the player character, mark it.
                // TODO: Inform player if the mission is above or below
                drew_mission = true;
                if( i != 0 || j != 0 ) {
                    ter_color = red_background( ter_color );
                }
            }
            if( i == 0 && j == 0 ) {
                mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
            } else {
                mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
            }
        }
    }
 
    // Print arrow to mission if we have one!
    if( !drew_mission ) {
        double slope = curs2.x() != targ.x() ?
                       static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
 
        if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
            if( targ.y() > curs2.y() ) {
                mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
            } else {
                mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
            }
        } else {
            int arrowx = -1;
            int arrowy = -1;
            if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
                arrowy = targ.y() > curs2.y() ? 6 : 0;
                arrowx =
                    static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
                if( arrowx < 0 ) {
                    arrowx = 0;
                }
                if( arrowx > 6 ) {
                    arrowx = 6;
                }
            } else {
                arrowx = targ.x() > curs2.x() ? 6 : 0;
                arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
                if( arrowy < 0 ) {
                    arrowy = 0;
                }
                if( arrowy > 6 ) {
                    arrowy = 6;
                }
            }
            char glyph = '*';
            if( targ.z() > u.posz() ) {
                glyph = '^';
            } else if( targ.z() < u.posz() ) {
                glyph = 'v';
            }
 
            mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
        }
    }
 
    const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
    for( int i = -3; i <= 3; i++ ) {
        for( int j = -3; j <= 3; j++ ) {
            if( i > -3 && i < 3 && j > -3 && j < 3 ) {
                continue; // only do hordes on the border, skip inner map
            }
            const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
            if( overmap_buffer.get_horde_size( omp ) >= HORDE_VISIBILITY_SIZE ) {
                if( overmap_buffer.seen( omp )
                    && g->u.overmap_los( omp, sight_points ) ) {
                    mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
                              overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
                }
            }
        }
    }
 
    wnoutrefresh( w_minimap );
}

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

draw_monster_override()

void game::draw_monster_override	(	const tripoint &	p,
		const mtype_id &	id,
		int	count,
		bool	more,
		Creature::Attitude	att
	)

Definition at line 969 of file animation.cpp.

{
}

draw_panels()

void game::draw_panels

(

bool

force_draw = false

)

Definition at line 3474 of file game.cpp.

{
    static int previous_turn = -1;
    const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
    const bool draw_this_turn = current_turn > previous_turn || force_draw;
    auto &mgr = panel_manager::get_manager();
    int y = 0;
    const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
    int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
    int log_height = 0;
    for( const window_panel &panel : mgr.get_current_layout() ) {
        if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
            log_height += panel.get_height() + spacer;
        }
    }
    log_height = std::max( TERMY - log_height, 3 );
    for( const window_panel &panel : mgr.get_current_layout() ) {
        if( panel.render() ) {
            // height clamped to window height.
            int h = std::min( panel.get_height(), TERMY - y );
            if( h == -2 ) {
                h = log_height;
            }
            h += spacer;
            if( panel.toggle && panel.render() && h > 0 ) {
                if( panel.always_draw || draw_this_turn ) {
                    panel.draw( u, catacurses::newwin( h, panel.get_width(),
                                                       point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
                }
                if( show_panel_adm ) {
                    const std::string panel_name = _( panel.get_name() );
                    const int panel_name_width = utf8_width( panel_name );
                    auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
                                                     TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
                    werase( label );
                    mvwprintz( label, point_zero, c_light_red, panel_name );
                    wnoutrefresh( label );
                    label = catacurses::newwin( h, 1,
                                                point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
                    werase( label );
                    if( h == 1 ) {
                        mvwputch( label, point_zero, c_light_red, LINE_OXOX );
                    } else {
                        mvwputch( label, point_zero, c_light_red, LINE_OXXX );
                        for( int i = 1; i < h - 1; i++ ) {
                            mvwputch( label, point( 0, i ), c_light_red, LINE_XOXO );
                        }
                        mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
                    }
                    wnoutrefresh( label );
                }
                y += h;
            }
        }
    }
    previous_turn = current_turn;
}

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

draw_pixel_minimap()

void game::draw_pixel_minimap

(

const catacurses::window &

w

)

Definition at line 3532 of file game.cpp.

{
    w_pixel_minimap = w;
}

References w_pixel_minimap.

draw_radiation_override()

void game::draw_radiation_override	(	const tripoint &	p,
		int	rad
	)

Definition at line 846 of file animation.cpp.

{
}

draw_sct()

void game::draw_sct

(

)

Definition at line 797 of file animation.cpp.

{
    draw_sct_curses( *this );
}

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

draw_ter() [1/2]

void game::draw_ter

(

bool

draw_sounds = true

)

Definition at line 3588 of file game.cpp.

{
    draw_ter( u.pos() + u.view_offset, is_looking,
              draw_sounds );
}

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

draw_ter() [2/2]

void game::draw_ter	(	const tripoint &	center,
		bool	looking = false,
		bool	draw_sounds = true
	)

Definition at line 3594 of file game.cpp.

{
    ter_view_p = center;
 
    m.draw( w_terrain, center );
 
    if( draw_sounds ) {
        draw_footsteps( w_terrain, tripoint( -center.x, -center.y, center.z ) + point( POSX, POSY ) );
    }
 
    for( Creature &critter : all_creatures() ) {
        draw_critter( critter, center );
    }
 
    if( !destination_preview.empty() && u.view_offset.z == 0 ) {
        // Draw auto-move preview trail
        const tripoint &final_destination = destination_preview.back();
        tripoint line_center = u.pos() + u.view_offset;
        draw_line( final_destination, line_center, destination_preview, true );
        mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
                  POSY - u.posy() ), c_white, 'X' );
    }
 
    if( u.controlling_vehicle && !looking ) {
        draw_veh_dir_indicator( false );
        draw_veh_dir_indicator( true );
    }
    // Place the cursor over the player as is expected by screen readers.
    wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
}

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

draw_terrain_override()

void game::draw_terrain_override	(	const tripoint &	p,
		const ter_id &	id
	)

Definition at line 859 of file animation.cpp.

{
}

draw_trail_to_square()

void game::draw_trail_to_square	(	const tripoint &	t,
		bool	bDrawX
	)

Definition at line 7251 of file game.cpp.

{
    ::draw_trail( u.pos(), u.pos() + t, bDrawX );
}

References draw_trail(), Character::pos(), and u.

draw_trap_override()

void game::draw_trap_override	(	const tripoint &	p,
		const trap_id &	id
	)

Definition at line 898 of file animation.cpp.

{
}

draw_veh_dir_indicator()

void game::draw_veh_dir_indicator

(

bool

next

)

Definition at line 3640 of file game.cpp.

{
    if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
        auto col = next ? c_white : c_dark_gray;
        mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
    }
}

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

draw_vpart_override()

void game::draw_vpart_override	(	const tripoint &	p,
		const vpart_id &	id,
		int	part_mod,
		units::angle	veh_dir,
		bool	hilite,
		const point &	mount
	)

Definition at line 941 of file animation.cpp.

{
}

draw_weather()

void game::draw_weather

(

const weather_printable &

wPrint

)

Definition at line 756 of file animation.cpp.

{
    draw_weather_curses( w_terrain, w );
}

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

draw_zones()

void game::draw_zones	(	const tripoint &	start,
		const tripoint &	end,
		const tripoint &	offset
	)

Definition at line 832 of file animation.cpp.

{
    draw_zones_curses( w_terrain, start, end, offset );
}

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

drop()

void game::drop ( )

private

Definition at line 8293 of file game.cpp.

{
    u.drop( game_menus::inv::multidrop( u ), u.pos() );
}

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

drop_in_direction()

void game::drop_in_direction ( )

private

Definition at line 8298 of file game.cpp.

{
    if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
        u.drop( game_menus::inv::multidrop( u ), *pnt );
    }
}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

dump_stats()

bool game::dump_stats	(	const std::string &	what,
		dump_mode	mode,
		const std::vector< std::string > &	opts
	)

write statistics to stdout and

Returns

true if successful

Definition at line 37 of file dump.cpp.

{
    try {
        loading_ui ui( false );
        load_core_data( ui );
        load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
        DynamicDataLoader::get_instance().finalize_loaded_data( ui );
    } catch( const std::exception &err ) {
        std::cerr << "Error loading data from json: " << err.what() << std::endl;
        return false;
    }
 
    std::vector<std::string> header;
    std::vector<std::vector<std::string>> rows;
 
    int scol = 0; // sorting column
 
    std::map<std::string, standard_npc> test_npcs;
    test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
                                      4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
    test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
                                      4, 8, 8, 8, 10 /* PER 10 */ );
    test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
                                      4, 10, 8, 8, 8 /* STAT 10 */ );
    test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
    test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
    test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
                                      4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
 
    std::map<std::string, item> test_items;
    test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
    test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
    test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
    test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
    test_items[ "G4" ].put_in( item( "rifle_scope" ) );
 
    if( what == "AMMO" ) {
        header = {
            "Name", "Ammo", "Volume", "Weight", "Stack",
            "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
        };
        auto dump = [&rows]( const item & obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( obj.ammo_type().str() );
            r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
            r.push_back( std::to_string( to_gram( obj.weight() ) ) );
            r.push_back( std::to_string( obj.type->stack_size ) );
            r.push_back( std::to_string( obj.type->ammo->range ) );
            r.push_back( std::to_string( obj.type->ammo->dispersion ) );
            r.push_back( std::to_string( obj.type->ammo->recoil ) );
            damage_instance damage = obj.type->ammo->damage;
            r.push_back( std::to_string( damage.total_damage() ) );
            r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
            rows.push_back( r );
        };
        for( const itype *e : item_controller->all() ) {
            if( e->ammo ) {
                dump( item( e, calendar::turn, item::solitary_tag {} ) );
            }
        }
 
    } else if( what == "ARMOR" ) {
        header = {
            "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
        };
        auto dump = [&rows]( const item & obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
            r.push_back( std::to_string( obj.get_warmth() ) );
            r.push_back( std::to_string( to_gram( obj.weight() ) ) );
            r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
            r.push_back( std::to_string( obj.get_coverage() ) );
            r.push_back( std::to_string( obj.bash_resist() ) );
            r.push_back( std::to_string( obj.cut_resist() ) );
            r.push_back( std::to_string( obj.bullet_resist() ) );
            r.push_back( std::to_string( obj.acid_resist() ) );
            r.push_back( std::to_string( obj.fire_resist() ) );
            rows.push_back( r );
        };
 
        body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
 
        for( const itype *e : item_controller->all() ) {
            if( e->armor ) {
                item obj( e );
                if( bp == num_bp || obj.covers( bp ) ) {
                    if( obj.has_flag( flag_VARSIZE ) ) {
                        obj.set_flag( "FIT" );
                    }
                    dump( obj );
                }
            }
        }
 
    } else if( what == "EDIBLE" ) {
        header = {
            "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
        };
        for( const auto &v : vitamin::all() ) {
            header.push_back( v.second.name() );
        }
        auto dump = [&rows]( const item & obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
            r.push_back( std::to_string( to_gram( obj.weight() ) ) );
            r.push_back( std::to_string( obj.type->stack_size ) );
            r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
            r.push_back( std::to_string( obj.get_comestible()->quench ) );
            r.push_back( std::to_string( obj.get_comestible()->healthy ) );
            auto vits = obj.get_comestible()->default_nutrition.vitamins;
            for( const auto &v : vitamin::all() ) {
                r.push_back( std::to_string( vits[ v.first ] ) );
            }
            rows.push_back( r );
        };
 
        for( const itype *e : item_controller->all() ) {
            item food( e, calendar::turn, item::solitary_tag {} );
 
            if( food.is_food() && g->u.can_eat( food ).success() ) {
                dump( food );
            }
        }
 
    } else if( what == "GUN" ) {
        header = {
            "Name", "Ammo", "Volume", "Weight", "Capacity",
            "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
            "Aim time", "Effective range", "Snapshot range", "Max range"
        };
 
        std::set<std::string> locations;
        for( const itype *e : item_controller->all() ) {
            if( e->gun ) {
                std::transform( e->gun->valid_mod_locations.begin(),
                                e->gun->valid_mod_locations.end(),
                                std::inserter( locations, locations.begin() ),
                []( const std::pair<gunmod_location, int> &q ) {
                    return q.first.name();
                } );
            }
        }
        for( const auto &e : locations ) {
            header.push_back( e );
        }
 
        auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
            std::vector<std::string> r;
            r.push_back( obj.tname( 1, false ) );
            r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
            obj.ammo_types().end(), []( const ammotype & at ) {
                return at.str();
            }, enumeration_conjunction::none ) : "" );
            r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
            r.push_back( std::to_string( to_gram( obj.weight() ) ) );
            r.push_back( std::to_string( obj.ammo_capacity() ) );
            r.push_back( std::to_string( obj.gun_range() ) );
            r.push_back( std::to_string( obj.gun_dispersion() ) );
            r.push_back( std::to_string( obj.gun_recoil() ) );
            damage_instance damage = obj.gun_damage();
            r.push_back( std::to_string( damage.total_damage() ) );
            r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
 
            r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
 
            for( const auto &e : locations ) {
                const auto &vml = obj.type->gun->valid_mod_locations;
                const auto iter = vml.find( e );
                r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
            }
            rows.push_back( r );
        };
        for( const itype *e : item_controller->all() ) {
            if( e->gun ) {
                item gun( e );
                if( !gun.magazine_integral() ) {
                    gun.put_in( item( gun.magazine_default() ) );
                }
                gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
 
                dump( test_npcs[ "S1" ], gun );
 
                if( gun.type->gun->barrel_length > 0_ml ) {
                    gun.put_in( item( "barrel_small" ) );
                    dump( test_npcs[ "S1" ], gun );
                }
            }
        }
 
    } else if( what == "RECIPE" ) {
 
        // optionally filter recipes to include only those using specified skills
        recipe_subset dict;
        for( const auto &r : recipe_dict ) {
            if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
            if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
                    return true;
                }
                const auto iter = r.second.required_skills.find( skill_id( s ) );
                return iter != r.second.required_skills.end() && iter->second > 0;
            } ) ) {
                dict.include( &r.second );
            }
        }
 
        // only consider skills that are required by at least one recipe
        std::vector<Skill> sk;
        std::copy_if( Skill::skills.begin(), Skill::skills.end(),
        std::back_inserter( sk ), [&dict]( const Skill & s ) {
            return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
                return r->skill_used == s.ident() ||
                       r->required_skills.find( s.ident() ) != r->required_skills.end();
            } );
        } );
 
        header = { "Result" };
 
        for( const auto &e : sk ) {
            header.push_back( e.ident().str() );
        }
 
        for( const recipe *e : dict ) {
            std::vector<std::string> r;
            r.push_back( e->result_name() );
            for( const auto &s : sk ) {
                if( e->skill_used == s.ident() ) {
                    r.push_back( std::to_string( e->difficulty ) );
                } else {
                    auto iter = e->required_skills.find( s.ident() );
                    r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
                }
            }
            rows.push_back( r );
        }
 
    } else if( what == "VEHICLE" ) {
        header = {
            "Name", "Weight (empty)", "Weight (fueled)",
            "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
            "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
        };
        auto dump = [&rows]( const vproto_id & obj ) {
            vehicle veh_empty( obj, 0, 0 );
            vehicle veh_fueled( obj, 100, 0 );
 
            std::vector<std::string> r;
            r.push_back( veh_empty.name );
            r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
            r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
            r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
            r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
            r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
            r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
            r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
            r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
            r.push_back( std::to_string( static_cast<int>( 50 *
                                         veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
            rows.push_back( r );
        };
        for( auto &e : vehicle_prototype::get_all() ) {
            dump( e );
        }
 
    } else if( what == "VPART" ) {
        header = {
            "Name", "Location", "Weight", "Size"
        };
        auto dump = [&rows]( const vpart_info & obj ) {
            std::vector<std::string> r;
            r.push_back( obj.name() );
            r.push_back( obj.location );
            int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
            r.push_back( std::to_string( w ) );
            r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
            rows.push_back( r );
        };
        for( const auto &e : vpart_info::all() ) {
            dump( e.second );
        }
 
    } else {
        std::cerr << "unknown argument: " << what << std::endl;
        return false;
    }
 
    rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
        return e.empty();
    } ), rows.end() );
 
    if( scol >= 0 ) {
        std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
        const std::vector<std::string> &rhs ) {
            return localized_compare( lhs[ scol ], rhs[ scol ] );
        } );
    }
 
    rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
 
    switch( mode ) {
        case dump_mode::TSV:
            rows.insert( rows.begin(), header );
            for( const auto &r : rows ) {
                // NOLINTNEXTLINE(cata-text-style): using tab to align the output
                std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
                std::cout << r.back() << "\n";
            }
            break;
 
        case dump_mode::HTML:
            std::cout << "<table>";
 
            std::cout << "<thead>";
            std::cout << "<tr>";
            for( const auto &col : header ) {
                std::cout << "<th>" << col << "</th>";
            }
            std::cout << "</tr>";
            std::cout << "</thead>";
 
            std::cout << "<tdata>";
            for( const auto &r : rows ) {
                std::cout << "<tr>";
                for( const auto &col : r ) {
                    std::cout << "<td>" << col << "</td>";
                }
                std::cout << "</tr>";
            }
            std::cout << "</tdata>";
 
            std::cout << "</table>";
            break;
    }
 
    return true;
}

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

events()

event_bus & game::events

(

)

Definition at line 3075 of file game.cpp.

{
    return *event_bus_ptr;
}

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

exam_vehicle()

void game::exam_vehicle	(	vehicle &	veh,
		const point &	cp = point_zero
	)

open vehicle interaction screen

Definition at line 5270 of file game.cpp.

{
    if( veh.magic ) {
        add_msg( m_info, _( "This is your %s" ), veh.name );
        return;
    }
    auto act = veh_interact::run( veh, c );
    if( act ) {
        u.moves = 0;
        u.assign_activity( act );
    }
}

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

examine() [1/2]

void game::examine ( )

private

Definition at line 5650 of file game.cpp.

{
    // if we are driving a vehicle, examine the
    // current tile without asking.
    const optional_vpart_position vp = m.veh_at( u.pos() );
    if( vp && vp->vehicle().player_in_control( u ) ) {
        examine( u.pos() );
        return;
    }
 
    const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
                                            _( "There is nothing that can be examined nearby." ),
                                            ACTION_EXAMINE, false );
    if( !examp_ ) {
        return;
    }
    u.manual_examine = true;
    examine( *examp_ );
    u.manual_examine = false;
}

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

examine() [2/2]

void game::examine ( const tripoint &  p )

private

Definition at line 5737 of file game.cpp.

{
    if( disable_robot( examp ) ) {
        return;
    }
 
    Creature *c = critter_at( examp );
    if( c != nullptr ) {
        monster *mon = dynamic_cast<monster *>( c );
        if( mon != nullptr ) {
            add_msg( _( "There is a %s." ), mon->get_name() );
            if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
                if( monexamine::pet_menu( *mon ) ) {
                    return;
                }
            } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
                if( monexamine::mech_hack( *mon ) ) {
                    return;
                }
            } else if( mon->has_flag( MF_PAY_BOT ) ) {
                if( monexamine::pay_bot( *mon ) ) {
                    return;
                }
            } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
                if( monexamine::mfriend_menu( *mon ) ) {
                    return;
                }
            }
        } else if( u.is_mounted() ) {
            add_msg( m_warning, _( "You cannot do that while mounted." ) );
        }
        npc *np = dynamic_cast<npc *>( c );
        if( np != nullptr && !u.is_mounted() ) {
            if( npc_menu( *np ) ) {
                return;
            }
        } else if( np != nullptr && u.is_mounted() ) {
            add_msg( m_warning, _( "You cannot do that while mounted." ) );
        }
    }
 
    const optional_vpart_position vp = m.veh_at( examp );
    if( vp && u.is_mounted() ) {
        if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
            add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
        } else {
            vp->vehicle().interact_with( examp, vp->part_index() );
            return;
        }
    } else if( vp && !u.is_mounted() ) {
        vp->vehicle().interact_with( examp, vp->part_index() );
        return;
    }
 
    if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
        use_computer( examp );
        return;
    } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
        add_msg( m_warning, _( "You cannot use a console while mounted." ) );
    }
    const furn_t &xfurn_t = m.furn( examp ).obj();
    const ter_t &xter_t = m.ter( examp ).obj();
 
    const tripoint player_pos = u.pos();
 
    if( m.has_furn( examp ) && !u.is_mounted() ) {
        xfurn_t.examine( u, examp );
    } else if( m.has_furn( examp ) && u.is_mounted() ) {
        add_msg( m_warning, _( "You cannot do that while mounted." ) );
    } else {
        if( !u.is_mounted() ) {
            xter_t.examine( u, examp );
        } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
            xter_t.examine( u, examp );
        } else {
            add_msg( m_warning, _( "You cannot do that while mounted." ) );
        }
    }
 
    // Did the player get moved? Bail out if so; our examp probably
    // isn't valid anymore.
    if( player_pos != u.pos() ) {
        return;
    }
 
    bool none = true;
    if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
        none = false;
    }
 
    if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
        iexamine::trap( u, examp );
    } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
        add_msg( m_warning, _( "You cannot do that while mounted." ) );
    }
 
    // In case of teleport trap or somesuch
    if( player_pos != u.pos() ) {
        return;
    }
 
    // Feedback for fire lasting time, this can be judged while mounted
    const std::string fire_fuel = get_fire_fuel_string( examp );
    if( !fire_fuel.empty() ) {
        add_msg( fire_fuel );
    }
 
    if( m.has_flag( "SEALED", examp ) ) {
        if( none ) {
            if( m.has_flag( "UNSTABLE", examp ) ) {
                add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
            } else {
                add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
            }
        }
    } else {
        //examp has no traps, is a container and doesn't have a special examination function
        if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
            m.has_flag( "CONTAINER", examp ) && none ) {
            add_msg( _( "It is empty." ) );
        } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
                     xfurn_t.examine == &iexamine::fireplace ) ||
                   xfurn_t.examine == &iexamine::workbench ) {
            return;
        } else {
            sounds::process_sound_markers( &u );
            if( !u.is_mounted() ) {
                pickup::pick_up( examp, 0 );
            }
        }
    }
}

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

extended_description()

void game::extended_description

(

const tripoint &

p

)

Long description of (visible) things at tile.

Definition at line 50 of file descriptions.cpp.

{
    ui_adaptor ui;
    const int top = 3;
    int width = 0;
    catacurses::window w_head;
    catacurses::window w_main;
    ui.on_screen_resize( [&]( ui_adaptor & ui ) {
        const int left = 0;
        const int right = TERMX;
        const int bottom = TERMY;
        width = right - left;
        const int height = bottom - top;
        w_head = catacurses::newwin( top, TERMX, point_zero );
        w_main = catacurses::newwin( height, width, point( left, top ) );
        ui.position( point_zero, point( TERMX, TERMY ) );
    } );
    ui.mark_resize();
 
    // Default to critter (if any), furniture (if any), then terrain.
    description_target cur_target = description_target::terrain;
    if( seen_critter( *this, p ) != nullptr ) {
        cur_target = description_target::creature;
    } else if( get_map().has_furn( p ) ) {
        cur_target = description_target::furniture;
    }
 
    std::string action;
    input_context ctxt( "EXTENDED_DESCRIPTION" );
    ctxt.register_action( "CREATURE" );
    ctxt.register_action( "FURNITURE" );
    ctxt.register_action( "TERRAIN" );
    ctxt.register_action( "CONFIRM" );
    ctxt.register_action( "QUIT" );
    ctxt.register_action( "HELP_KEYBINDINGS" );
 
    ui.on_redraw( [&]( const ui_adaptor & ) {
        werase( w_head );
        mvwprintz( w_head, point_zero, c_white,
                   _( "[%s] describe creatures, [%s] describe furniture, "
                      "[%s] describe terrain, [%s] close." ),
                   ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
                   ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
 
        // Set up line drawings
        for( int i = 0; i < TERMX; i++ ) {
            mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
        }
 
        wnoutrefresh( w_head );
 
        std::string desc;
        // Allow looking at invisible tiles - player may want to examine hallucinations etc.
        switch( cur_target ) {
            case description_target::creature: {
                const Creature *critter = seen_critter( *this, p );
                if( critter != nullptr ) {
                    desc = critter->extended_description();
                } else {
                    desc = _( "You do not see any creature here." );
                }
            }
            break;
            case description_target::furniture:
                if( !u.sees( p ) || !m.has_furn( p ) ) {
                    desc = _( "You do not see any furniture here." );
                } else {
                    const furn_id fid = m.furn( p );
                    desc = fid.obj().extended_description();
                }
                break;
            case description_target::terrain:
                if( !u.sees( p ) ) {
                    desc = _( "You can't see the terrain here." );
                } else {
                    const ter_id tid = m.ter( p );
                    desc = tid.obj().extended_description();
                }
                break;
        }
 
        std::string signage = m.get_signage( p );
        if( !signage.empty() ) {
            // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
            desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
                    signage );
        }
 
        werase( w_main );
        fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
        wnoutrefresh( w_main );
    } );
 
    do {
        ui_manager::redraw();
        action = ctxt.handle_input();
        if( action == "CREATURE" ) {
            cur_target = description_target::creature;
        } else if( action == "FURNITURE" ) {
            cur_target = description_target::furniture;
        } else if( action == "TERRAIN" ) {
            cur_target = description_target::terrain;
        }
    } while( action != "CONFIRM" && action != "QUIT" );
}

References _, action, c_light_gray, c_white, creature, map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius )

private

Definition at line 7185 of file game.cpp.

{
    std::map<std::string, map_item_stack> temp_items;
    std::vector<map_item_stack> ret;
    std::vector<std::string> item_order;
 
    if( u.is_blind() ) {
        return ret;
    }
 
    for( auto &points_p_it : closest_points_first( u.pos(), iRadius ) ) {
        if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
            u.sees( points_p_it ) &&
            m.sees_some_items( points_p_it, u ) ) {
 
            for( auto &elem : m.i_at( points_p_it ) ) {
                const std::string name = elem.tname();
                const tripoint relative_pos = points_p_it - u.pos();
 
                if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
                    item_order.push_back( name );
                    temp_items[name] = map_item_stack( &elem, relative_pos );
                } else {
                    temp_items[name].add_at_pos( &elem, relative_pos );
                }
            }
        }
    }
 
    for( auto &elem : item_order ) {
        ret.push_back( temp_items[elem] );
    }
 
    return ret;
}

References closest_points_first(), detail::find(), map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), and u.

Referenced by list_items_monsters().

find_npc()

npc * game::find_npc

(

character_id

id

)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1951 of file game.cpp.

{
    return overmap_buffer.find_npc( id ).get();
}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs	(	map &	mp,
		int	z_after,
		bool &	rope_ladder,
		bool	peeking
	)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10943 of file game.cpp.

{
    const int omtilesz = SEEX * 2;
    real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
    tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
    tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
 
    // Try to find the stairs.
    cata::optional<tripoint> stairs;
    int best = INT_MAX;
    const int movez = z_after - get_levz();
    const bool going_down_1 = movez == -1;
    const bool going_up_1 = movez == 1;
    // If there are stairs on the same x and y as we currently are, use those
    if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
        stairs.emplace( u.pos() + tripoint_below );
    }
    if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
        stairs.emplace( u.pos() + tripoint_above );
    }
    // We did not find stairs directly above or below, so search the map for them
    if( !stairs.has_value() ) {
        for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
            if( rl_dist( u.pos(), dest ) <= best &&
                ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
                  ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
                                    mp.ter( dest ) == t_manhole_cover ) ) ||
                  ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
                stairs.emplace( dest );
                best = rl_dist( u.pos(), dest );
            }
        }
    }
 
    if( stairs.has_value() ) {
        if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
            npc *guy = dynamic_cast<npc *>( blocking_creature );
            monster *mon = dynamic_cast<monster *>( blocking_creature );
            bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
            bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
            std::string cr_name = blocking_creature->get_name();
            std::string msg;
            if( guy ) {
                //~ %s is the name of hostile NPC
                msg = string_format( _( "%s is in the way!" ), cr_name );
            } else {
                //~ %s is some monster
                msg = string_format( _( "There's a %s in the way!" ), cr_name );
            }
 
            if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
                        //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
                        _( "%s  Attempt to push past?  You may have to fight your way back up." ), msg ) ) ) {
                add_msg( msg );
                return cata::nullopt;
            }
        }
        return stairs;
    }
 
    // No stairs found! Try to make some
    rope_ladder = false;
    stairs.emplace( u.pos() );
    stairs->z = z_after;
    // Check the destination area for lava.
    if( mp.ter( *stairs ) == t_lava ) {
        if( movez < 0 &&
            !query_yn(
                _( "There is a LOT of heat coming out of there, even the stairs have melted away.  Jump down?  You won't be able to get back up." ) ) ) {
            return cata::nullopt;
        } else if( movez > 0 &&
                   !query_yn(
                       _( "There is a LOT of heat coming out of there.  Push through the half-molten rocks and ascend?  You will not be able to get back down." ) ) ) {
            return cata::nullopt;
        }
 
        return stairs;
    }
 
    if( movez > 0 ) {
        if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
            if( !query_yn( _( "You may be unable to return back down these stairs.  Continue up?" ) ) ) {
                return cata::nullopt;
            }
        }
        // Manhole covers need this to work
        // Maybe require manhole cover here and fail otherwise?
        return stairs;
    }
 
    if( mp.impassable( *stairs ) ) {
        popup( _( "Halfway down, the way down becomes blocked off." ) );
        return cata::nullopt;
    }
 
    if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
        if( query_yn( _( "There is a sheer drop halfway down.  Web-descend?" ) ) ) {
            rope_ladder = true;
            if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
                add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
            } else {
                add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
            }
        } else {
            return cata::nullopt;
        }
    } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
        if( query_yn( _( "There is a sheer drop halfway down.  Use your vines to descend?" ) ) ) {
            if( u.has_trait( trait_VINES2 ) ) {
                if( query_yn( _( "Detach a vine?  It'll hurt, but you'll be able to climb back up…" ) ) ) {
                    rope_ladder = true;
                    add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
                    u.mod_pain( 5 );
                    u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
                    u.mod_stored_nutr( 10 );
                    u.mod_thirst( 10 );
                } else {
                    add_msg( _( "You gingerly descend using your vines." ) );
                }
            } else {
                add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
                rope_ladder = true;
                u.mod_stored_nutr( 10 );
                u.mod_thirst( 10 );
            }
        } else {
            return cata::nullopt;
        }
    } else if( u.has_amount( itype_grapnel, 1 ) ) {
        if( query_yn( _( "There is a sheer drop halfway down.  Climb your grappling hook down?" ) ) ) {
            rope_ladder = true;
            u.use_amount( itype_grapnel, 1 );
        } else {
            return cata::nullopt;
        }
    } else if( u.has_amount( itype_rope_30, 1 ) ) {
        if( query_yn( _( "There is a sheer drop halfway down.  Climb your rope down?" ) ) ) {
            rope_ladder = true;
            u.use_amount( itype_rope_30, 1 );
        } else {
            return cata::nullopt;
        }
    } else if( !query_yn( _( "There is a sheer drop halfway down.  Jump?" ) ) ) {
        return cata::nullopt;
    }
 
    return stairs;
}

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

fling_creature()

void game::fling_creature	(	Creature *	c,
		const units::angle &	dir,
		float	flvel,
		bool	controlled = false,
		bool	suppress_map_update = false
	)

Flings the input creature in the given direction.

Definition at line 10305 of file game.cpp.

{
    if( c == nullptr ) {
        debugmsg( "game::fling_creature invoked on null target" );
        return;
    }
 
    if( c->is_dead_state() ) {
        // Flinging a corpse causes problems, don't enable without testing
        return;
    }
 
    if( c->is_hallucination() ) {
        // Don't fling hallucinations
        return;
    }
 
    int steps = 0;
    bool thru = true;
    const bool is_u = ( c == &u );
    // Don't animate critters getting bashed if animations are off
    const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
 
    player *p = dynamic_cast<player *>( c );
 
    tileray tdir( dir );
    int range = flvel / 10;
    tripoint pt = c->pos();
    while( range > 0 ) {
        c->underwater = false;
        // TODO: Check whenever it is actually in the viewport
        // or maybe even just redraw the changed tiles
        bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
        tdir.advance();
        pt.x = c->posx() + tdir.dx();
        pt.y = c->posy() + tdir.dy();
        float force = 0;
 
        if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
            monster &critter = *mon_ptr;
            // Approximate critter's "stopping power" with its max hp
            force = std::min<float>( 1.5f * critter.type->hp, flvel );
            const int damage = rng( force, force * 2.0f ) / 6;
            c->impact( damage, pt );
            // Multiply zed damage by 6 because no body parts
            const int zed_damage = std::max( 0,
                                             ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
            // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
            critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
            critter.check_dead_state();
            if( !critter.is_dead() ) {
                thru = false;
            }
        } else if( m.impassable( pt ) ) {
            if( !m.veh_at( pt ).obstacle_at_part() ) {
                force = std::min<float>( m.bash_strength( pt ), flvel );
            } else {
                // No good way of limiting force here
                // Keep it 1 less than maximum to make the impact hurt
                // but to keep the target flying after it
                force = flvel - 1;
            }
            const int damage = rng( force, force * 2.0f ) / 9;
            c->impact( damage, pt );
            if( m.is_bashable( pt ) ) {
                // Only go through if we successfully make the tile passable
                m.bash( pt, flvel );
                thru = m.passable( pt );
            } else {
                thru = false;
            }
        }
 
        // If the critter dies during flinging, moving it around causes debugmsgs
        if( c->is_dead_state() ) {
            return;
        }
 
        flvel -= force;
        if( thru ) {
            if( p != nullptr ) {
                if( p->in_vehicle ) {
                    m.unboard_vehicle( p->pos() );
                }
                // If we're flinging the player around, make sure the map stays centered on them.
                if( is_u && !suppress_map_update ) {
                    update_map( pt.x, pt.y );
                } else {
                    p->setpos( pt );
                }
            } else if( !critter_at( pt ) ) {
                // Dying monster doesn't always leave an empty tile (blob spawning etc.)
                // Just don't setpos if it happens - next iteration will do so
                // or the monster will stop a tile before the unpassable one
                c->setpos( pt );
            }
        } else {
            // Don't zero flvel - count this as slamming both the obstacle and the ground
            // although at lower velocity
            break;
        }
        range--;
        steps++;
        if( animate && ( seen || u.sees( *c ) ) ) {
            invalidate_main_ui_adaptor();
            ui_manager::redraw_invalidated();
            refresh_display();
        }
    }
 
    // Fall down to the ground - always on the last reached tile
    if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
        const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
        // Didn't smash into a wall or a floor so only take the fall damage
        if( thru && trap_under_creature == tr_ledge ) {
            m.creature_on_trap( *c, false );
        } else {
            // Fall on ground
            int force = rng( flvel, flvel * 2 ) / 9;
            if( controlled ) {
                force = std::max( force / 2 - 5, 0 );
            }
            if( force > 0 ) {
                int dmg = c->impact( force, c->pos() );
                // TODO: Make landing damage the floor
                m.bash( c->pos(), dmg / 4, false, false, false );
            }
            // Always apply traps to creature i.e. bear traps, tele traps etc.
            m.creature_on_trap( *c, false );
        }
    } else {
        c->underwater = true;
        if( is_u ) {
            if( controlled ) {
                add_msg( _( "You dive into water." ) );
            } else {
                add_msg( m_warning, _( "You fall into water." ) );
            }
        }
    }
}

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

forced_door_closing()

bool game::forced_door_closing	(	const tripoint &	p,
		const ter_id &	door_type,
		int	bash_dmg
	)

Definition at line 5283 of file game.cpp.

{
    // TODO: Z
    const int &x = p.x;
    const int &y = p.y;
    const std::string &door_name = door_type.obj().name();
    // sed when player/monsters are knocked back and when moving items out of the way
    point kb( x, y );
    const auto valid_location = [&]( const tripoint & p ) {
        return g->is_empty( p );
    };
    if( const cata::optional<tripoint> pos = random_point( m.points_in_radius( p, 2 ),
            valid_location ) ) {
        kb.x = -pos->x + x + x;
        kb.y = -pos->y + y + y;
    }
    const tripoint kbp( kb, p.z );
    if( kbp == p ) {
        // can't pushback any creatures anywhere, that means the door can't close.
        return false;
    }
    const bool can_see = u.sees( tripoint( x, y, p.z ) );
    player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
    if( npc_or_player != nullptr ) {
        if( bash_dmg <= 0 ) {
            return false;
        }
        if( npc_or_player->is_npc() && can_see ) {
            add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
        } else if( npc_or_player->is_player() ) {
            add_msg( m_bad, _( "The %s hits you." ), door_name );
        }
        if( npc_or_player->activity ) {
            npc_or_player->cancel_activity();
        }
        // TODO: make the npc angry?
        npc_or_player->hitall( bash_dmg, 0, nullptr );
        knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
        // TODO: perhaps damage/destroy the gate
        // if the npc was really big?
    }
    if( monster *const mon_ptr = critter_at<monster>( p ) ) {
        monster &critter = *mon_ptr;
        if( bash_dmg <= 0 ) {
            return false;
        }
        if( can_see ) {
            add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
        }
        if( critter.type->size <= MS_SMALL ) {
            critter.die_in_explosion( nullptr );
        } else {
            critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
            critter.check_dead_state();
        }
        if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
            // big critters simply prevent the gate from closing
            // TODO: perhaps damage/destroy the gate
            // if the critter was really big?
            return false;
        }
        if( !critter.is_dead() ) {
            // Still alive? Move the critter away so the door can close
            knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
            if( critter_at( p ) ) {
                return false;
            }
        }
    }
    if( const optional_vpart_position vp = m.veh_at( p ) ) {
        if( bash_dmg <= 0 ) {
            return false;
        }
        vp->vehicle().damage( vp->part_index(), bash_dmg );
        if( m.veh_at( p ) ) {
            // Check again in case all parts at the door tile
            // have been destroyed, if there is still a vehicle
            // there, the door can not be closed
            return false;
        }
    }
    if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
        return false;
    }
    if( bash_dmg == 0 ) {
        for( auto &elem : m.i_at( point( x, y ) ) ) {
            if( elem.made_of( LIQUID ) ) {
                // Liquids are OK, will be destroyed later
                continue;
            } else if( elem.volume() < 250_ml ) {
                // Dito for small items, will be moved away
                continue;
            }
            // Everything else prevents the door from closing
            return false;
        }
    }
 
    m.ter_set( point( x, y ), door_type );
    if( m.has_flag( "NOITEM", point( x, y ) ) ) {
        map_stack items = m.i_at( point( x, y ) );
        for( map_stack::iterator it = items.begin(); it != items.end(); ) {
            if( it->made_of( LIQUID ) ) {
                it = items.erase( it );
                continue;
            }
            if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
                if( can_see ) {
                    add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
                } else {
                    add_msg( m_warning, _( "Something shatters!" ) );
                }
                it = items.erase( it );
                continue;
            }
            m.add_item_or_charges( kbp, *it );
            it = items.erase( it );
        }
    }
    return true;
}

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

gametype()

special_game_id game::gametype

(

)

const

Definition at line 626 of file game.cpp.

{
    return gamemode ? gamemode->id() : SGAME_NULL;
}

References gamemode, and SGAME_NULL.

get_creature_if()

Creature * game::get_creature_if

(

const std::function< bool(const Creature &)> &

pred

)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12516 of file game.cpp.

{
    for( Creature &critter : all_creatures() ) {
        if( pred( critter ) ) {
            return &critter;
        }
    }
    return nullptr;
}

References all_creatures().

get_creatures_if()

std::vector< Creature * > game::get_creatures_if

(

const std::function< bool(const Creature &)> &

pred

)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12426 of file game.cpp.

{
    std::vector<Creature *> result;
    for( Creature &critter : all_creatures() ) {
        if( pred( critter ) ) {
            result.push_back( &critter );
        }
    }
    return result;
}

References all_creatures().

get_cur_om()

overmap & game::get_cur_om

(

)

const

The overmap which contains the center submap of the reality bubble.

Definition at line 12406 of file game.cpp.

{
    // The player is located in the middle submap of the map.
    const tripoint sm = m.get_abs_sub() + tripoint( HALF_MAPSIZE, HALF_MAPSIZE, 0 );
    const tripoint pos_om = sm_to_om_copy( sm );
    // TODO: fix point types
    return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
}

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile

(

const tripoint &

dest_loc

)

const

Definition at line 9263 of file game.cpp.

{
    std::vector<std::string> harmful_stuff;
    const auto fields_here = m.field_at( u.pos() );
    for( const auto &e : m.field_at( dest_loc ) ) {
        // warn before moving into a dangerous field except when already standing within a similar field
        if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
            harmful_stuff.push_back( e.second.name() );
        }
    }
 
    if( !u.is_blind() ) {
        const trap &tr = m.tr_at( dest_loc );
        const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
                               true ) );
        // HACK: Hack for now, later ledge should stop being a trap
        // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
        if( tr.loadid == tr_ledge && m.has_zlevels() ) {
            if( !boardable ) {
                harmful_stuff.emplace_back( tr.name() );
            }
        } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
            harmful_stuff.emplace_back( tr.name() );
        }
 
        static const std::set< body_part > sharp_bps = {
            bp_eyes, bp_mouth, bp_head, bp_leg_l, bp_leg_r, bp_foot_l, bp_foot_r, bp_arm_l, bp_arm_r,
            bp_hand_l, bp_hand_r, bp_torso
        };
 
        const auto sharp_bp_check = [this]( body_part bp ) {
            return u.immune_to( bp, { DT_CUT, 10 } );
        };
 
        if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
            ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
              u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
            harmful_stuff.emplace_back( m.name( dest_loc ) );
        } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
                   g->m.veh_at( dest_loc ) ) &&
                   u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
            harmful_stuff.emplace_back( m.name( dest_loc ) );
        }
 
    }
 
    return harmful_stuff;
}

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), g, Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations	(	int	distance,
		const tripoint &	fish_pos
	)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters

distance	Distance around the fish_pos to examine for contiguous fishable locations.
fish_pos	The location being fished.

Returns

A set of locations representing the valid contiguous fishable locations.

Definition at line 3957 of file game.cpp.

{
    // We're going to get the contiguous fishable terrain starting at
    // the provided fishing location (e.g. where a line was cast or a fish
    // trap was set), and then check whether or not fishable monsters are
    // actually in those locations. This will help us ensure that we're
    // getting our fish from the location that we're ACTUALLY fishing,
    // rather than just somewhere in the vicinity.
 
    std::unordered_set<tripoint> visited;
 
    const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
    const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
 
    const inclusive_cuboid<tripoint> fishing_boundaries(
        fishing_boundary_min, fishing_boundary_max );
 
    const auto get_fishable_terrain = [&]( tripoint starting_point,
    std::unordered_set<tripoint> &fishable_terrain ) {
        std::queue<tripoint> to_check;
        to_check.push( starting_point );
        while( !to_check.empty() ) {
            const tripoint current_point = to_check.front();
            to_check.pop();
 
            // We've been here before, so bail.
            if( visited.find( current_point ) != visited.end() ) {
                continue;
            }
 
            // This point is out of bounds, so bail.
            if( !fishing_boundaries.contains( current_point ) ) {
                continue;
            }
 
            // Mark this point as visited.
            visited.emplace( current_point );
 
            if( m.has_flag( "FISHABLE", current_point ) ) {
                fishable_terrain.emplace( current_point );
                to_check.push( current_point + point_south );
                to_check.push( current_point + point_north );
                to_check.push( current_point + point_east );
                to_check.push( current_point + point_west );
            }
        }
        return;
    };
 
    // Starting at the provided location, get our fishable terrain
    // and populate a set with those locations which we'll then use
    // to determine if any fishable monsters are in those locations.
    std::unordered_set<tripoint> fishable_points;
    get_fishable_terrain( fish_pos, fishable_points );
 
    return fishable_points;
}

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters

(

std::unordered_set< tripoint > &

fishable_locations

)

Get the fishable monsters within the provided fishable locations.

Parameters

fishable_locations

A set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.

Returns

Fishable monsters within the specified fishable terrain.

Definition at line 4015 of file game.cpp.

{
    std::vector<monster *> unique_fish;
    for( monster &critter : all_monsters() ) {
        // If it is fishable...
        if( critter.has_flag( MF_FISHABLE ) ) {
            const tripoint critter_pos = critter.pos();
            // ...and it is in a fishable location.
            if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
                unique_fish.push_back( &critter );
            }
        }
    }
 
    return unique_fish;
}

References all_monsters(), and MF_FISHABLE.

get_follower_list()

std::set< character_id > game::get_follower_list

(

)

Get set of followers.

Definition at line 2048 of file game.cpp.

{
    return follower_ids;
}

References follower_ids.

get_kill_tracker()

const kill_tracker & game::get_kill_tracker

(

)

const

Definition at line 965 of file game.cpp.

{
    return *kill_tracker_ptr;
}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

get_levx()

int game::get_levx

(

)

const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 12391 of file game.cpp.

{
    return m.get_abs_sub().x;
}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

get_levy()

int game::get_levy

(

)

const

Definition at line 12396 of file game.cpp.

{
    return m.get_abs_sub().y;
}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

get_levz()

int game::get_levz

(

)

const

Definition at line 12401 of file game.cpp.

{
    return m.get_abs_sub().z;
}

References map::get_abs_sub(), m, and tripoint::z.

Referenced by do_turn(), draw_minimap(), find_or_make_stairs(), get_player_input(), scent_map::get_unsafe(), scent_map::inbounds(), load_npcs(), look_around(), perhaps_add_random_npc(), place_player(), place_player_overmap(), replace_stair_monsters(), start_game(), update_map(), update_stair_monsters(), vertical_move(), and vertical_shift().

get_moves_since_last_save()

int game::get_moves_since_last_save

(

)

const

Definition at line 7355 of file game.cpp.

{
    return moves_since_last_save;
}

References moves_since_last_save.

get_npcs_if()

std::vector< npc * > game::get_npcs_if

(

const std::function< bool(const npc &)> &

pred

)

Definition at line 12438 of file game.cpp.

{
    std::vector<npc *> result;
    for( npc &guy : all_npcs() ) {
        if( pred( guy ) ) {
            result.push_back( &guy );
        }
    }
    return result;
}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

get_player_base_save_path()

std::string game::get_player_base_save_path

(

)

const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12526 of file game.cpp.

{
    return get_world_base_save_path() + "/" + base64_encode( u.name );
}

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

get_player_input()

input_context game::get_player_input ( std::string &  action )

private

Definition at line 238 of file handle_action.cpp.

{
    input_context ctxt;
    if( uquit == QUIT_WATCH ) {
        ctxt = input_context( "DEFAULTMODE" );
        ctxt.set_iso( true );
        // The list of allowed actions in death-cam mode in game::handle_action
        // *INDENT-OFF*
        for( const action_id id : {
            ACTION_TOGGLE_MAP_MEMORY,
            ACTION_CENTER,
            ACTION_SHIFT_N,
            ACTION_SHIFT_NE,
            ACTION_SHIFT_E,
            ACTION_SHIFT_SE,
            ACTION_SHIFT_S,
            ACTION_SHIFT_SW,
            ACTION_SHIFT_W,
            ACTION_SHIFT_NW,
            ACTION_LOOK,
            ACTION_KEYBINDINGS,
        } ) {
            ctxt.register_action( action_ident( id ) );
        }
        // *INDENT-ON*
        ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
    } else {
        ctxt = get_default_mode_input_context();
    }
 
    m.update_visibility_cache( u.posz() );
 
    user_turn current_turn;
 
 
    // Checking early if we will need to handle animations
    // If we do not need to handle animations that will not change as long as the user has not selected an action
    // and we can handle it like we are not animating.
    weather_printable wPrint;
    bool animate_weather = false;
    bool animate_sct = false;
    bool do_animations = [&]() {
        if( get_option<bool>( "ANIMATIONS" ) ) {
            const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
 
            animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
            animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
 
#if defined(TILES)
            // Always animate, minimap and terrain may have animations to run
            return true;
#else
            // Otherwise we need to see if we actually should animate.
            // Minimap and Terrain never animate in !TILES
            return animate_weather || animate_sct || uquit == QUIT_WATCH;
#endif
        }
        return false;
    }
    ();
 
    if( do_animations ) {
        ctxt.set_timeout( 125 );
 
        shared_ptr_fast<game::draw_callback_t> animation_cb =
        make_shared_fast<game::draw_callback_t>( [&]() {
            if( animate_weather ) {
                draw_weather( wPrint );
            }
            if( animate_sct ) {
                draw_sct();
            }
        } );
        add_draw_callback( animation_cb );
        invalidate_main_ui_adaptor(); // We want to redraw at least once.
 
        do {
            if( animate_weather ) {
                invalidate_main_ui_adaptor();
                generate_weather_anim_frame( get_weather().weather_id, wPrint );
            }
            // don't bother calculating SCT if we won't show it
            if( animate_sct ) {
                invalidate_main_ui_adaptor();
 
                SCT.advanceAllSteps();
 
                //Check for creatures on all drawing positions and offset if necessary
                for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
                    const direction oCurDir = iter->getDirecton();
                    const int width = utf8_width( iter->getText() );
                    for( int i = 0; i < width; ++i ) {
                        tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
                        const Creature *critter = critter_at( tmp, true );
 
                        if( critter != nullptr && u.sees( *critter ) ) {
                            i = -1;
                            int iPos = iter->getStep() + iter->getStepOffset();
                            for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
                                if( iter2->getDirecton() == oCurDir &&
                                    iter2->getStep() + iter2->getStepOffset() <= iPos ) {
                                    if( iter2->getType() == "hp" ) {
                                        iter2->advanceStepOffset();
                                    }
 
                                    iter2->advanceStepOffset();
                                    iPos = iter2->getStep() + iter2->getStepOffset();
                                }
                            }
                        }
                    }
                }
 
                // Stop animation when done
                animate_sct = !SCT.vSCT.empty();
            }
            // We don't cache these checks as their result may change after 1st redraw
            if( minimap_requires_animation() || terrain_requires_animation() ) {
                // TODO: we redraw *everything* just to animate a couple blinking dots
                //       on the minimap or a few tiles.
                //       This is far from ideal, and can probably be done much cheaper
                //       (update only part of the screen? draw static parts into a texture?)
                invalidate_main_ui_adaptor();
            }
 
            std::unique_ptr<static_popup> deathcam_msg_popup;
            if( uquit == QUIT_WATCH ) {
                deathcam_msg_popup = std::make_unique<static_popup>();
                deathcam_msg_popup
                ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
                .on_top( true );
            }
 
            ui_manager::redraw_invalidated();
        } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
                 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
        ctxt.reset_timeout();
    } else {
        invalidate_main_ui_adaptor();
        ui_manager::redraw_invalidated();
        SCT.vSCT.clear();
 
        ctxt.set_timeout( 125 );
        while( handle_mouseview( ctxt, action ) ) {
            if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
                break;
            }
        }
        ctxt.reset_timeout();
    }
 
    return ctxt;
}

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

get_seed()

unsigned int game::get_seed

(

)

const

Definition at line 1861 of file game.cpp.

{
    return seed;
}

References seed.

get_user_action_counter()

int game::get_user_action_counter

(

)

const

Definition at line 7360 of file game.cpp.

{
    return user_action_counter;
}

References user_action_counter.

get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location

(

bool

next

)

const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters

next	If true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3625 of file game.cpp.

{
    if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
        return cata::nullopt;
    }
    const optional_vpart_position vp = m.veh_at( u.pos() );
    if( !vp ) {
        return cata::nullopt;
    }
    vehicle *const veh = &vp->vehicle();
    rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
    float r = 10.0;
    return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
}

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

get_world_base_save_path()

std::string game::get_world_base_save_path

(

)

const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12531 of file game.cpp.

{
    if( world_generator->active_world == nullptr ) {
        return PATH_INFO::savedir();
    }
    return world_generator->active_world->folder_path();
}

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

get_zoom()

int game::get_zoom

(

)

const

Definition at line 7346 of file game.cpp.

{
#if defined(TILES)
    return tileset_zoom;
#else
    return DEFAULT_TILESET_ZOOM;
#endif
}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint &  dp )

private

Strength determines ability to drag furniture

Definition at line 10065 of file game.cpp.

{
    // Furniture: pull, push, or standing still and nudging object around.
    // Can push furniture out of reach.
    tripoint fpos = u.pos() + u.grab_point;
    // supposed position of grabbed furniture
    if( !m.has_furn( fpos ) ) {
        // Where did it go? We're grabbing thin air so reset.
        add_msg( m_info, _( "No furniture at grabbed point." ) );
        u.grab( OBJECT_NONE );
        return false;
    }
 
    const bool pushing_furniture = dp ==  u.grab_point;
    const bool pulling_furniture = dp == -u.grab_point;
    const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
 
    tripoint fdest = fpos + dp; // intended destination of furniture.
    // Check floor: floorless tiles don't need to be flat and have no traps
    const bool has_floor = m.has_floor( fdest );
    // Unfortunately, game::is_empty fails for tiles we're standing on,
    // which will forbid pulling, so:
    const bool canmove = (
                             m.passable( fdest ) &&
                             critter_at<npc>( fdest ) == nullptr &&
                             critter_at<monster>( fdest ) == nullptr &&
                             ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
                             ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
                             !m.has_furn( fdest ) &&
                             !m.veh_at( fdest ) &&
                             ( !has_floor || m.tr_at( fdest ).is_null() )
                         );
 
    const furn_t furntype = m.furn( fpos ).obj();
    const int src_items = m.i_at( fpos ).size();
    const int dst_items = m.i_at( fdest ).size();
 
    const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
    [&]( item & liquid_item ) {
        return liquid_item.made_of( LIQUID );
    } );
 
    const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
                             !m.has_flag( "SWIMMABLE", fdest ) &&
                             !m.has_flag( "DESTROY_ITEM", fdest );
 
    const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
                             m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
                             m.furn( fpos ).obj().has_flag( "SEALED" );
 
    const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
    time_duration fire_age = m.get_field_age( fpos, fd_fire );
 
    int str_req = furntype.move_str_req;
    // Factor in weight of items contained in the furniture.
    units::mass furniture_contents_weight = 0_gram;
    for( auto &contained_item : m.i_at( fpos ) ) {
        furniture_contents_weight += contained_item.weight();
    }
    str_req += furniture_contents_weight / 4_kilogram;
    if( !canmove ) {
        // TODO: What is something?
        add_msg( _( "The %s collides with something." ), furntype.name() );
        u.moves -= 50;
        return true;
        ///\EFFECT_STR determines ability to drag furniture
    } else if( str_req > u.get_str() &&
               one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
        add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
                 furntype.name() );
        u.moves -= 100;
        u.mod_pain( 1 ); // Hurt ourselves.
        return true; // furniture and or obstacle wins.
    } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
        add_msg( _( "There's stuff in the way." ) );
        u.moves -= 50;
        return true;
    }
 
    u.moves -= str_req * 10;
    // Additional penalty if we can't comfortably move it.
    if( str_req > u.get_str() ) {
        int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
        if( move_penalty <= 1000 ) {
            if( u.get_str() >= str_req - 3 ) {
                u.moves -= std::max( 3000, move_penalty * 10 );
                add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
                if( one_in( 3 ) ) {
                    add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
                    return true;
                }
            } else {
                u.moves -= 100;
                add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
                return true;
            }
        }
        u.moves -= move_penalty;
        if( move_penalty > 500 ) {
            add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
                     furntype.name() );
        } else if( move_penalty > 200 ) {
            if( one_in( 3 ) ) { // Nag only occasionally.
                add_msg( _( "It takes some time to move the heavy %s." ),
                         furntype.name() );
            }
        }
    }
    sounds::sound( fdest, furntype.move_str_req * 2, sounds::sound_t::movement,
                   _( "a scraping noise." ), true, "misc", "scraping" );
 
    active_tile_data *atd = active_tiles::furn_at<active_tile_data>
                            ( tripoint_abs_ms( m.getabs( fpos ) ) );
 
    // Actually move the furniture.
    m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
    m.furn_set( fpos, f_null );
 
    if( fire_intensity == 1 && !pulling_furniture ) {
        m.remove_field( fpos, fd_fire );
        m.set_field_intensity( fdest, fd_fire, fire_intensity );
        m.set_field_age( fdest, fd_fire, fire_age );
    }
 
    // Is there is only liquids on the ground, remove them after moving furniture.
    if( dst_items > 0 && only_liquid_items ) {
        m.i_clear( fdest );
    }
 
    if( src_items > 0 ) { // Move the stuff inside.
        if( dst_item_ok && src_item_ok ) {
            // Assume contents of both cells are legal, so we can just swap contents.
            std::list<item> temp;
            std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
                       std::back_inserter( temp ) );
            m.i_clear( fpos );
            for( auto item_iter = m.i_at( fdest ).begin();
                 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
                m.i_at( fpos ).insert( *item_iter );
            }
            m.i_clear( fdest );
            for( auto &cur_item : temp ) {
                m.i_at( fdest ).insert( cur_item );
            }
        } else {
            add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
        }
    }
 
    if( shifting_furniture ) {
        // We didn't move
        tripoint d_sum = u.grab_point + dp;
        if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
            u.grab_point = d_sum; // furniture moved relative to us
        } else { // we pushed furniture out of reach
            add_msg( _( "You let go of the %s." ), furntype.name() );
            u.grab( OBJECT_NONE );
        }
        return true; // We moved furniture but stayed still.
    }
 
    if( pushing_furniture && m.impassable( fpos ) ) {
        // Not sure how that chair got into a wall, but don't let player follow.
        add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
                 furntype.name(), m.tername( fdest ) );
        u.grab( OBJECT_NONE );
        return true;
    }
 
    return false;
}

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

grabbed_move()

bool game::grabbed_move ( const tripoint &  dp )

private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 10237 of file game.cpp.

{
    if( u.get_grab_type() == OBJECT_NONE ) {
        return false;
    }
 
    if( dp.z != 0 ) {
        // No dragging stuff up/down stairs yet!
        return false;
    }
 
    // vehicle: pulling, pushing, or moving around the grabbed object.
    if( u.get_grab_type() == OBJECT_VEHICLE ) {
        return grabbed_veh_move( dp );
    }
 
    if( u.get_grab_type() == OBJECT_FURNITURE ) {
        return grabbed_furn_move( dp );
    }
 
    add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
             u.grab_point.x, u.grab_point.y, u.grab_point.z );
    u.grab( OBJECT_NONE );
    return false;
}

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint &  dp )

private

Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

{
    const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
    if( !grabbed_vehicle_vp ) {
        add_msg( m_info, _( "No vehicle at grabbed point." ) );
        u.grab( OBJECT_NONE );
        return false;
    }
    vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
    if( !grabbed_vehicle ||
        !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
        return false;
    }
    const int grabbed_part = grabbed_vehicle_vp->part_index();
    for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
        monster *mon = grabbed_vehicle->get_pet( part_index );
        if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
            add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
                     mon->get_name() );
            u.grab( OBJECT_NONE );
            return false;
        }
    }
    const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
    if( grabbed_vehicle == veh_under_player ) {
        u.grab_point = -dp;
        return false;
    }
 
    tripoint dp_veh = -u.grab_point;
    const tripoint prev_grab = u.grab_point;
    tripoint next_grab = u.grab_point;
 
    bool zigzag = false;
 
    if( dp == prev_grab ) {
        // We are pushing in the direction of vehicle
        dp_veh = dp;
    } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
        // Not actually moving the vehicle, don't do the checks
        u.grab_point = -( dp + dp_veh );
        return false;
    } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
               next_grab.x != 0 && next_grab.y != 0 ) {
        // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
        // and moves away from it, but not directly away
        dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
        dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
 
        next_grab = -dp_veh;
        zigzag = true;
    } else {
        // We are pulling the vehicle
        next_grab = -dp;
    }
 
    // Make sure the mass and pivot point are correct
    grabbed_vehicle->invalidate_mass();
 
    //vehicle movement: strength check
    int mc = 0;
    int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
 
    //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
 
    // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
    // (Roughly 1.1K kg = danger zone; cube vans are about the max)
    if( str_req > 45 ) {
        add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
                 grabbed_vehicle->name );
        return true; // No shoving around an RV.
    }
 
    const auto &wheel_indices = grabbed_vehicle->wheelcache;
    if( grabbed_vehicle->valid_wheel_config() ) {
        //determine movecost for terrain touching wheels
        const tripoint vehpos = grabbed_vehicle->global_pos3();
        for( int p : wheel_indices ) {
            const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
            const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
            mc += str_req / wheel_indices.size() * mapcost;
        }
        //set strength check threshold
        //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
        if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
            str_req = mc / 4 + 1;
        } else {
            str_req = mc / wheel_indices.size() + 1;
        }
    } else {
        str_req++;
        //if vehicle has no wheels str_req make a noise.
        if( str_req <= u.get_str() ) {
            sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
                           _( "a scraping noise." ), true, "misc", "scraping" );
        }
    }
 
    //final strength check and outcomes
    ///\EFFECT_STR determines ability to drag vehicles
    if( str_req <= u.get_str() ) {
        //calculate exertion factor and movement penalty
        ///\EFFECT_STR increases speed of dragging vehicles
        u.moves -= 100 * str_req / std::max( 1, u.get_str() );
        const int ex = dice( 1, 3 ) - 1 + str_req;
        if( ex > u.get_str() + 1 ) {
            // Pain and movement penalty if exertion exceeds character strength
            add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
            u.moves -= 200;
            u.mod_pain( 1 );
        } else if( ex >= u.get_str() ) {
            // Movement is slow if exertion nearly equals character strength
            add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
            u.moves -= 200;
        }
    } else {
        u.moves -= 100;
        add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
        return true;
    }
 
    std::string blocker_name = _( "errors in movement code" );
    const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
        tileray mdir;
 
        mdir.init( dir.xy() );
        grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
        grabbed_vehicle->face = grabbed_vehicle->turn_dir;
        grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
 
        // Grabbed part has to stay at distance 1 to the player
        // and in roughly the same direction.
        const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
                                      grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
        const tripoint expected_pos = u.pos() + dp + from;
        const tripoint actual_dir = expected_pos - new_part_pos;
 
        // Set player location to illegal value so it can't collide with vehicle.
        const tripoint player_prev = u.pos();
        u.setpos( tripoint_zero );
        std::vector<veh_collision> colls;
        const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
        u.setpos( player_prev );
        if( !colls.empty() ) {
            blocker_name = colls.front().target_name;
        }
        return failed ? tripoint_zero : actual_dir;
    };
 
    // First try the move as intended
    // But if that fails and the move is a zig-zag, try to recover:
    // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
    tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
    if( final_dp_veh == tripoint_zero && zigzag ) {
        final_dp_veh = get_move_dir( -prev_grab, -dp );
        next_grab = -dp;
    }
 
    if( final_dp_veh == tripoint_zero ) {
        add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
        u.grab_point = prev_grab;
        return true;
    }
 
    u.grab_point = next_grab;
 
    m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
 
    if( grabbed_vehicle ) {
        m.level_vehicle( *grabbed_vehicle );
        grabbed_vehicle->check_falling_or_floating();
    } else {
        debugmsg( "Grabbed vehicle disappeared" );
        return false;
    }
 
    for( int p : wheel_indices ) {
        if( one_in( 2 ) ) {
            tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
            grabbed_vehicle->handle_trap( wheel_p, p );
        }
    }
 
    return false;
 
}

References _, add_msg(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), map::level_vehicle(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

handle_action()

bool game::handle_action ( )

private

Definition at line 1516 of file handle_action.cpp.

{
    std::string action;
    input_context ctxt;
    action_id act = ACTION_NULL;
    user_turn current_turn;
    // Check if we have an auto-move destination
    if( u.has_destination() ) {
        act = u.get_next_auto_move_direction();
        if( act == ACTION_NULL ) {
            add_msg( m_info, _( "Auto-move canceled" ) );
            u.clear_destination();
            return false;
        }
    } else if( u.has_destination_activity() ) {
        // starts destination activity after the player successfully reached his destination
        u.start_destination_activity();
        return false;
    } else {
        // No auto-move, ask player for input
        ctxt = get_player_input( action );
    }
 
    const optional_vpart_position vp = m.veh_at( u.pos() );
    bool veh_ctrl = !u.is_dead_state() &&
                    ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
 
    // If performing an action with right mouse button, co-ordinates
    // of location clicked.
    cata::optional<tripoint> mouse_target;
 
    if( uquit == QUIT_WATCH && action == "QUIT" ) {
        uquit = QUIT_DIED;
        return false;
    }
 
    if( act == ACTION_NULL ) {
        act = look_up_action( action );
 
        if( act == ACTION_KEYBINDINGS ) {
            // already handled by input context
            return false;
        }
 
        if( act == ACTION_MAIN_MENU ) {
            if( uquit == QUIT_WATCH ) {
                return false;
            }
            // No auto-move actions have or can be set at this point.
            u.clear_destination();
            destination_preview.clear();
            act = handle_main_menu();
            if( act == ACTION_NULL ) {
                return false;
            }
        }
 
        if( act == ACTION_ACTIONMENU ) {
            if( uquit == QUIT_WATCH ) {
                return false;
            }
            // No auto-move actions have or can be set at this point.
            u.clear_destination();
            destination_preview.clear();
            act = handle_action_menu();
            if( act == ACTION_NULL ) {
                return false;
            }
#if defined(__ANDROID__)
            if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
                add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
            }
#endif
        }
 
        if( act == ACTION_KEYBINDINGS ) {
            u.clear_destination();
            destination_preview.clear();
            act = ctxt.display_menu( true );
            if( act == ACTION_NULL ) {
                return false;
            }
        }
 
        if( can_action_change_worldstate( act ) ) {
            user_action_counter += 1;
        }
 
        if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
            // Mouse button click
            if( veh_ctrl ) {
                // No mouse use in vehicle
                return false;
            }
 
            if( u.is_dead_state() ) {
                // do not allow mouse actions while dead
                return false;
            }
 
            const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
            if( !mouse_pos ) {
                return false;
            } else if( !u.sees( *mouse_pos ) ) {
                // Not clicked in visible terrain
                return false;
            }
            mouse_target = mouse_pos;
 
            if( act == ACTION_SELECT ) {
                // Note: The following has the potential side effect of
                // setting auto-move destination state in addition to setting
                // act.
                if( !try_get_left_click_action( act, *mouse_target ) ) {
                    return false;
                }
            } else if( act == ACTION_SEC_SELECT ) {
                if( !try_get_right_click_action( act, *mouse_target ) ) {
                    return false;
                }
            }
        } else if( act != ACTION_TIMEOUT ) {
            // act has not been set for an auto-move, so clearing possible
            // auto-move destinations. Since initializing an auto-move with
            // the mouse may span across multiple actions, we do not clear the
            // auto-move destination if the action is only a timeout, as this
            // would require the user to double click quicker than the
            // timeout delay.
            u.clear_destination();
            destination_preview.clear();
        }
    }
 
    if( act == ACTION_NULL ) {
        const input_event &&evt = ctxt.get_raw_input();
        if( !evt.sequence.empty() ) {
            const int ch = evt.get_first_input();
            const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
            if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
                add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
                if( const cata::optional<std::string> hint =
                        press_x_if_bound( ACTION_KEYBINDINGS ) ) {
                    add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
                                        "the current context." ),
                             *hint );
                }
            }
        }
        return false;
    }
 
    // This has no action unless we're in a special game mode.
    gamemode->pre_action( act );
 
    int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
 
    int before_action_moves = u.moves;
 
    // These actions are allowed while deathcam is active. Registered in game::get_player_input
    if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
        switch( act ) {
            case ACTION_TOGGLE_MAP_MEMORY:
                u.toggle_map_memory();
                break;
 
            case ACTION_CENTER:
                u.view_offset.x = driving_view_offset.x;
                u.view_offset.y = driving_view_offset.y;
                break;
 
            case ACTION_SHIFT_N:
            case ACTION_SHIFT_NE:
            case ACTION_SHIFT_E:
            case ACTION_SHIFT_SE:
            case ACTION_SHIFT_S:
            case ACTION_SHIFT_SW:
            case ACTION_SHIFT_W:
            case ACTION_SHIFT_NW: {
                static const std::map<action_id, std::pair<point, point>> shift_delta = {
                    { ACTION_SHIFT_N, { point_north, point_north_east } },
                    { ACTION_SHIFT_NE, { point_north_east, point_east } },
                    { ACTION_SHIFT_E, { point_east, point_south_east } },
                    { ACTION_SHIFT_SE, { point_south_east, point_south } },
                    { ACTION_SHIFT_S, { point_south, point_south_west } },
                    { ACTION_SHIFT_SW, { point_south_west, point_west } },
                    { ACTION_SHIFT_W, { point_west, point_north_west } },
                    { ACTION_SHIFT_NW, { point_north_west, point_north } },
                };
                u.view_offset += use_tiles && tile_iso ?
                                 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
            }
            break;
 
            case ACTION_LOOK:
                look_around();
                break;
 
            case ACTION_KEYBINDINGS:
                // already handled by input context
                break;
 
            default:
                break;
        }
    }
 
    // actions allowed only while alive
    if( !u.is_dead_state() ) {
        switch( act ) {
            case ACTION_NULL:
            case NUM_ACTIONS:
                break; // dummy entries
            case ACTION_ACTIONMENU:
            case ACTION_MAIN_MENU:
            case ACTION_KEYBINDINGS:
                break; // handled above
 
            case ACTION_TIMEOUT:
                if( check_safe_mode_allowed( false ) ) {
                    u.pause();
                }
                break;
 
            case ACTION_PAUSE:
                if( check_safe_mode_allowed() ) {
                    u.pause();
                }
                break;
 
            case ACTION_CYCLE_MOVE:
                u.cycle_move_mode();
                break;
 
            case ACTION_RESET_MOVE:
                u.reset_move_mode();
                break;
 
            case ACTION_TOGGLE_RUN:
                u.toggle_run_mode();
                break;
 
            case ACTION_TOGGLE_CROUCH:
                u.toggle_crouch_mode();
                break;
 
            case ACTION_OPEN_MOVEMENT:
                open_movement_mode_menu();
                break;
 
            case ACTION_MOVE_FORTH:
            case ACTION_MOVE_FORTH_RIGHT:
            case ACTION_MOVE_RIGHT:
            case ACTION_MOVE_BACK_RIGHT:
            case ACTION_MOVE_BACK:
            case ACTION_MOVE_BACK_LEFT:
            case ACTION_MOVE_LEFT:
            case ACTION_MOVE_FORTH_LEFT:
                if( !u.get_value( "remote_controlling" ).empty() &&
                    ( u.has_active_item( itype_radiocontrol ) ||
                      u.has_active_bionic( bio_remote ) ) ) {
                    rcdrive( get_delta_from_movement_action( act, iso_rotate::yes ) );
                } else if( veh_ctrl ) {
                    // vehicle control uses x for steering and y for ac/deceleration,
                    // so no rotation needed
                    pldrive( get_delta_from_movement_action( act, iso_rotate::no ) );
                } else {
                    point dest_delta = get_delta_from_movement_action( act, iso_rotate::yes );
                    if( auto_travel_mode && !u.is_auto_moving() ) {
                        for( int i = 0; i < SEEX; i++ ) {
                            tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
                                                              u.posy() + dest_delta.y * ( SEEX - i ),
                                                              u.posz() );
                            destination_preview = m.route( u.pos(),
                                                           auto_travel_destination,
                                                           u.get_pathfinding_settings(),
                                                           u.get_path_avoid() );
                            if( !destination_preview.empty() ) {
                                destination_preview.erase( destination_preview.begin() + 1, destination_preview.end() );
                                u.set_destination( destination_preview );
                                break;
                            }
                        }
                        act = u.get_next_auto_move_direction();
                        const point dest_next = get_delta_from_movement_action( act, iso_rotate::yes );
                        if( dest_next == point_zero ) {
                            u.clear_destination();
                        }
                        dest_delta = dest_next;
                    }
                    if( !avatar_action::move( u, m, dest_delta ) ) {
                        // auto-move should be canceled due to a failed move or obstacle
                        u.clear_destination();
                    }
                }
                break;
            case ACTION_MOVE_DOWN:
                if( u.is_mounted() ) {
                    auto mon = u.mounted_creature.get();
                    if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
                        add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
                        break;
                    }
                }
                if( !u.in_vehicle ) {
                    vertical_move( -1, false );
                } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
                    pldrive( tripoint_below );
                }
                break;
 
            case ACTION_MOVE_UP:
                if( u.is_mounted() ) {
                    auto mon = u.mounted_creature.get();
                    if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
                        add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
                        break;
                    }
                }
                if( !u.in_vehicle ) {
                    vertical_move( 1, false );
                } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
                    pldrive( tripoint_above );
                } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
                           !vp->vehicle().has_sufficient_rotorlift() ) {
                    add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
                }
                break;
 
            case ACTION_OPEN:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't open things while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't open things while you're riding." ) );
                } else {
                    open();
                }
                break;
 
            case ACTION_CLOSE:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't close things while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    auto mon = u.mounted_creature.get();
                    if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
                        add_msg( m_info, _( "You can't close things while you're riding." ) );
                    }
                } else if( mouse_target ) {
                    doors::close_door( m, u, *mouse_target );
                } else {
                    close();
                }
                break;
 
            case ACTION_SMASH:
                if( veh_ctrl ) {
                    handbrake();
                } else if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
                } else {
                    smash();
                }
                break;
 
            case ACTION_EXAMINE:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
                } else if( mouse_target ) {
                    examine( *mouse_target );
                } else {
                    examine();
                }
                break;
 
            case ACTION_ADVANCEDINV:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
                } else {
                    create_advanced_inv();
                }
                break;
 
            case ACTION_PICKUP:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
                } else if( mouse_target ) {
                    pickup( *mouse_target );
                } else {
                    pickup();
                }
                break;
 
            case ACTION_PICKUP_FEET:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
                } else {
                    pickup_feet();
                }
                break;
 
            case ACTION_GRAB:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't grab things while you're riding." ) );
                } else {
                    grab();
                }
                break;
 
            case ACTION_HAUL:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't haul things while you're riding." ) );
                } else {
                    haul();
                }
                break;
 
            case ACTION_BUTCHER:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't butcher while you're riding." ) );
                } else {
                    butcher();
                }
                break;
 
            case ACTION_CHAT:
                chat();
                break;
 
            case ACTION_PEEK:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
                } else {
                    peek();
                }
                break;
 
            case ACTION_LIST_ITEMS:
                list_items_monsters();
                break;
 
            case ACTION_ZONES:
                zones_manager();
                break;
 
            case ACTION_LOOT:
                loot();
                break;
 
            case ACTION_INVENTORY:
                game_menus::inv::common( u );
                break;
 
            case ACTION_COMPARE:
                game_menus::inv::compare( u, cata::nullopt );
                break;
 
            case ACTION_ORGANIZE:
                game_menus::inv::swap_letters( u );
                break;
 
            case ACTION_USE:
                // Shell-users are presumed to be able to mess with their inventories, etc
                // while in the shell.  Eating, gear-changing, and item use are OK.
                avatar_action::use_item( u );
                break;
 
            case ACTION_USE_WIELDED:
                u.use_wielded();
                break;
 
            case ACTION_WEAR:
                wear();
                break;
 
            case ACTION_TAKE_OFF:
                takeoff();
                break;
 
            case ACTION_EAT:
                if( !avatar_action::eat_here( u ) ) {
                    avatar_action::eat( u );
                }
                break;
 
            case ACTION_OPEN_CONSUME:
                if( !avatar_action::eat_here( u ) ) {
                    open_consume_item_menu();
                }
                break;
 
            case ACTION_READ:
                // Shell-users are presumed to have the book just at an opening and read it that way
                read();
                break;
 
            case ACTION_WIELD:
                wield();
                break;
 
            case ACTION_PICK_STYLE:
                u.martial_arts_data->pick_style( u );
                break;
 
            case ACTION_RELOAD_ITEM:
                reload_item();
                break;
 
            case ACTION_RELOAD_WEAPON:
                reload_weapon();
                break;
 
            case ACTION_RELOAD_WIELDED:
                reload_wielded();
                break;
 
            case ACTION_UNLOAD:
                avatar_action::unload( u );
                break;
 
            case ACTION_MEND:
                avatar_action::mend( g->u, item_location() );
                break;
 
            case ACTION_THROW: {
                item_location loc;
                avatar_action::plthrow( g->u, loc );
                break;
            }
 
            case ACTION_FIRE:
                fire();
                break;
 
            case ACTION_CAST_SPELL:
                cast_spell();
                break;
 
            case ACTION_FIRE_BURST: {
                if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
                    avatar_action::fire_wielded_weapon( u );
                }
                break;
            }
 
            case ACTION_SELECT_FIRE_MODE:
                if( u.is_armed() ) {
                    if( u.weapon.is_gun() && !u.weapon.is_gunmod() && u.weapon.gun_all_modes().size() > 1 ) {
                        u.weapon.gun_cycle_mode();
                    } else if( u.weapon.has_flag( flag_RELOAD_ONE ) || u.weapon.has_flag( flag_RELOAD_AND_SHOOT ) ) {
                        item::reload_option opt = u.select_ammo( u.weapon, false );
                        if( !opt ) {
                            break;
                        } else if( u.ammo_location && opt.ammo == u.ammo_location ) {
                            u.ammo_location = item_location();
                        } else {
                            u.ammo_location = opt.ammo;
                        }
                    }
                }
                break;
 
            case ACTION_DROP:
                // You CAN drop things to your own tile while in the shell.
                drop();
                break;
 
            case ACTION_DIR_DROP:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
                } else {
                    drop_in_direction();
                }
                break;
            case ACTION_BIONICS:
                u.power_bionics();
                break;
            case ACTION_MUTATIONS:
                u.power_mutations();
                break;
 
            case ACTION_SORT_ARMOR:
                u.sort_armor();
                break;
 
            case ACTION_WAIT:
                wait();
                break;
 
            case ACTION_CRAFT:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't craft while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't craft while you're riding." ) );
                } else {
                    u.craft();
                }
                break;
 
            case ACTION_RECRAFT:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't craft while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't craft while you're riding." ) );
                } else {
                    u.recraft();
                }
                break;
 
            case ACTION_LONGCRAFT:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't craft while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't craft while you're riding." ) );
                } else {
                    u.long_craft();
                }
                break;
 
            case ACTION_DISASSEMBLE:
                if( u.controlling_vehicle ) {
                    add_msg( m_info, _( "You can't disassemble items while driving." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
                } else {
                    u.disassemble();
                }
                break;
 
            case ACTION_CONSTRUCT:
                if( u.in_vehicle ) {
                    add_msg( m_info, _( "You can't construct while in a vehicle." ) );
                } else if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't construct while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    add_msg( m_info, _( "You can't construct while you're riding." ) );
                } else {
                    construction_menu( false );
                }
                break;
 
            case ACTION_SLEEP:
                if( veh_ctrl ) {
                    add_msg( m_info, _( "Vehicle control has moved, %s" ),
                             press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
                                      _( "new default binding is '^'." ) ) );
                } else {
                    sleep();
                }
                break;
 
            case ACTION_CONTROL_VEHICLE:
                if( u.has_active_mutation( trait_SHELL2 ) ) {
                    add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
                } else if( u.is_mounted() ) {
                    u.dismount();
                } else {
                    control_vehicle();
                }
                break;
 
            case ACTION_TOGGLE_AUTO_TRAVEL_MODE:
                auto_travel_mode = !auto_travel_mode;
                add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
                break;
 
            case ACTION_TOGGLE_SAFEMODE:
                if( safe_mode == SAFE_MODE_OFF ) {
                    set_safe_mode( SAFE_MODE_ON );
                    mostseen = 0;
                    add_msg( m_info, _( "Safe mode ON!" ) );
                } else {
                    turnssincelastmon = 0;
                    set_safe_mode( SAFE_MODE_OFF );
                    add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
                             ? _( "Safe mode OFF!  (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
                }
                if( u.has_effect( effect_laserlocked ) ) {
                    u.remove_effect( effect_laserlocked );
                    safe_mode_warning_logged = false;
                }
                break;
 
            case ACTION_TOGGLE_AUTOSAFE: {
                auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
                add_msg( m_info, autosafemode_option.value_as<bool>()
                         ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
                autosafemode_option.setNext();
                break;
            }
 
            case ACTION_IGNORE_ENEMY:
                if( safe_mode == SAFE_MODE_STOP ) {
                    add_msg( m_info, _( "Ignoring enemy!" ) );
                    for( auto &elem : u.get_mon_visible().new_seen_mon ) {
                        monster &critter = *elem;
                        critter.ignoring = rl_dist( u.pos(), critter.pos() );
                    }
                    set_safe_mode( SAFE_MODE_ON );
                } else if( u.has_effect( effect_laserlocked ) ) {
                    if( u.has_trait( trait_PROF_CHURL ) ) {
                        add_msg( m_warning, _( "You make the sign of the cross." ) );
                    } else {
                        add_msg( m_info, _( "Ignoring laser targeting!" ) );
                    }
                    u.remove_effect( effect_laserlocked );
                    safe_mode_warning_logged = false;
                }
                break;
 
            case ACTION_WHITELIST_ENEMY:
                if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
                    get_safemode().add_rule( get_safemode().lastmon_whitelist, Creature::A_ANY, 0, RULE_WHITELISTED );
                    add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
                    set_safe_mode( SAFE_MODE_ON );
                    mostseen = 0;
                } else {
                    get_safemode().show();
                }
                break;
 
            case ACTION_SUICIDE:
                if( query_yn( _( "Commit suicide?" ) ) ) {
                    if( query_yn( _( "REALLY commit suicide?" ) ) ) {
                        u.moves = 0;
                        u.place_corpse();
                        uquit = QUIT_SUICIDE;
                    }
                }
                break;
 
            case ACTION_SAVE:
                if( query_yn( _( "Save and quit?" ) ) ) {
                    if( save() ) {
                        u.moves = 0;
                        uquit = QUIT_SAVED;
                    }
                }
                break;
 
            case ACTION_QUICKSAVE:
                quicksave();
                return false;
 
            case ACTION_QUICKLOAD:
                quickload();
                return false;
 
            case ACTION_PL_INFO:
                u.disp_info();
                break;
 
            case ACTION_MAP:
                ui::omap::display();
                break;
 
            case ACTION_SKY:
                if( m.is_outside( u.pos() ) ) {
                    ui::omap::display_visible_weather();
                } else {
                    add_msg( m_info, _( "You can't see the sky from here." ) );
                }
                break;
 
            case ACTION_MISSIONS:
                list_missions();
                break;
 
            case ACTION_SCORES:
                show_scores_ui( *achievements_tracker_ptr, stats(), get_kill_tracker() );
                break;
 
            case ACTION_FACTIONS:
                faction_manager_ptr->display();
                break;
 
            case ACTION_MORALE:
                u.disp_morale();
                break;
 
            case ACTION_MESSAGES:
                Messages::display_messages();
                break;
 
            case ACTION_HELP:
                get_help().display_help();
                break;
 
            case ACTION_OPTIONS:
                get_options().show( true );
                break;
 
            case ACTION_AUTOPICKUP:
                get_auto_pickup().show();
                break;
 
            case ACTION_AUTONOTES:
                get_auto_notes_settings().show_gui();
                break;
 
            case ACTION_SAFEMODE:
                get_safemode().show();
                break;
 
            case ACTION_COLOR:
                all_colors.show_gui();
                break;
 
            case ACTION_WORLD_MODS:
                world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
                break;
 
            case ACTION_DEBUG:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                debug_menu::debug();
                break;
 
            case ACTION_TOGGLE_FULLSCREEN:
                toggle_fullscreen();
                break;
 
            case ACTION_TOGGLE_PIXEL_MINIMAP:
                toggle_pixel_minimap();
                break;
 
            case ACTION_TOGGLE_PANEL_ADM:
                panel_manager::get_manager().show_adm();
                break;
 
            case ACTION_RELOAD_TILESET:
                reload_tileset();
                break;
 
            case ACTION_TOGGLE_AUTO_FEATURES:
                get_options().get_option( "AUTO_FEATURES" ).setNext();
                get_options().save();
                //~ Auto Features are now ON/OFF
                add_msg( _( "%s are now %s." ),
                         get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
                         get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
                break;
 
            case ACTION_TOGGLE_AUTO_PULP_BUTCHER:
                get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
                get_options().save();
                //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
                add_msg( _( "%s is now set to %s." ),
                         get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
                         get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
                break;
 
            case ACTION_TOGGLE_AUTO_MINING:
                get_options().get_option( "AUTO_MINING" ).setNext();
                get_options().save();
                //~ Auto Mining is now ON/OFF
                add_msg( _( "%s is now %s." ),
                         get_options().get_option( "AUTO_MINING" ).getMenuText(),
                         get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
                break;
 
            case ACTION_TOGGLE_THIEF_MODE:
                if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
                    u.set_value( "THIEF_MODE", "THIEF_HONEST" );
                    u.set_value( "THIEF_MODE_KEEP", "YES" );
                    //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
                    add_msg( _( "You will not pick up other peoples belongings." ) );
                } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
                    u.set_value( "THIEF_MODE", "THIEF_STEAL" );
                    u.set_value( "THIEF_MODE_KEEP", "YES" );
                    //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
                    add_msg( _( "You will pick up also those things that belong to others!" ) );
                } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
                    u.set_value( "THIEF_MODE", "THIEF_ASK" );
                    u.set_value( "THIEF_MODE_KEEP", "NO" );
                    //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
                    add_msg( _( "You will be reminded not to steal." ) );
                } else {
                    // ERROR
                    add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
                }
                break;
 
            case ACTION_TOGGLE_AUTO_FORAGING:
                get_options().get_option( "AUTO_FORAGING" ).setNext();
                get_options().save();
                //~ Auto Foraging is now set to x
                add_msg( _( "%s is now set to %s." ),
                         get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
                         get_options().get_option( "AUTO_FORAGING" ).getValueName() );
                break;
 
            case ACTION_TOGGLE_AUTO_PICKUP:
                get_options().get_option( "AUTO_PICKUP" ).setNext();
                get_options().save();
                //~ Auto pickup is now set to x
                add_msg( _( "%s is now set to %s." ),
                         get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
                         get_options().get_option( "AUTO_PICKUP" ).getValueName() );
                break;
 
            case ACTION_DISPLAY_SCENT:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_scent();
                break;
 
            case ACTION_DISPLAY_SCENT_TYPE:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_scent();
                break;
 
            case ACTION_DISPLAY_TEMPERATURE:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_temperature();
                break;
            case ACTION_DISPLAY_VEHICLE_AI:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_vehicle_ai();
                break;
            case ACTION_DISPLAY_VISIBILITY:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_visibility();
                break;
 
            case ACTION_DISPLAY_LIGHTING:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_lighting();
                break;
 
            case ACTION_DISPLAY_RADIATION:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_radiation();
                break;
 
            case ACTION_DISPLAY_TRANSPARENCY:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                display_transparency();
                break;
 
            case ACTION_DISPLAY_SUBMAP_GRID:
                g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
                break;
 
            case ACTION_TOGGLE_HOUR_TIMER:
                toggle_debug_hour_timer();
                break;
 
            case ACTION_TOGGLE_DEBUG_MODE:
                if( MAP_SHARING::isCompetitive() && !MAP_SHARING::isDebugger() ) {
                    break;    //don't do anything when sharing and not debugger
                }
                debug_mode = !debug_mode;
                if( debug_mode ) {
                    add_msg( m_info, _( "Debug mode ON!" ) );
                } else {
                    add_msg( m_info, _( "Debug mode OFF!" ) );
                }
                break;
 
            case ACTION_ZOOM_IN:
                zoom_in();
                mark_main_ui_adaptor_resize();
                break;
 
            case ACTION_ZOOM_OUT:
                zoom_out();
                mark_main_ui_adaptor_resize();
                break;
 
            case ACTION_ITEMACTION:
                item_action_menu();
                break;
 
            case ACTION_AUTOATTACK:
                avatar_action::autoattack( u, m );
                break;
 
            default:
                break;
        }
    }
    if( act != ACTION_TIMEOUT ) {
        u.mod_moves( -current_turn.moves_elapsed() );
    }
    gamemode->post_action( act );
 
    u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
    dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
                                      to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
    return ( !u.is_dead_state() );
}

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, item::reload_option::ammo, player::ammo_location, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, player::disassemble(), Character::dismount(), player::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), flag_RELOAD_AND_SHOOT(), flag_RELOAD_ONE(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), item::has_flag(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), reload_item(), reload_tileset(), reload_weapon(), reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, player::select_ammo(), input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )

private

Definition at line 2053 of file game.cpp.

{
    input_context ctxt = get_default_mode_input_context();
    const std::string action = ctxt.handle_input( 0 );
    bool refresh = true;
    if( action == "pause" ) {
        if( u.activity.interruptable_with_kb ) {
            cancel_activity_query( _( "Confirm:" ) );
        }
    } else if( action == "player_data" ) {
        u.disp_info();
    } else if( action == "messages" ) {
        Messages::display_messages();
    } else if( action == "help" ) {
        get_help().display_help();
    } else if( action != "HELP_KEYBINDINGS" ) {
        refresh = false;
    }
    if( refresh ) {
        ui_manager::redraw();
        refresh_display();
    }
}

References _, action, Character::activity, cancel_activity_query(), player::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

handle_mouseview()

bool game::handle_mouseview ( input_context &  ctxt, std::string &  action  )

private

Definition at line 2310 of file game.cpp.

{
    cata::optional<tripoint> liveview_pos;
 
    do {
        action = ctxt.handle_input();
        if( action == "MOUSE_MOVE" ) {
            const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
            if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
                liveview_pos = mouse_pos;
                liveview.show( *liveview_pos );
            } else if( !mouse_pos ) {
                liveview_pos.reset();
                liveview.hide();
            }
            ui_manager::redraw();
        }
    } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
 
    if( action != "TIMEOUT" ) {
        // Keyboard event, break out of animation loop
        liveview.hide();
        return false;
    }
 
    // Mouse movement or un-handled key
    return true;
}

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

has_gametype()

bool game::has_gametype

(

)

const

Definition at line 621 of file game.cpp.

{
    return gamemode && gamemode->id() != SGAME_NULL;
}

References gamemode, and SGAME_NULL.

init_autosave()

void game::init_autosave ( )

private

Definition at line 11784 of file game.cpp.

{
    moves_since_last_save = 0;
    last_save_timestamp = time( nullptr );
}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

inv_map_splice()

item_location game::inv_map_splice	(	item_filter	filter,
		const std::string &	title,
		int	radius = 0,
		const std::string &	none_message = ""
	)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 392 of file game_inventory.cpp.

{
    return inv_internal( u, inventory_filter_preset( convert_filter( filter ) ),
                         title, radius, none_message );
}

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

Referenced by reload_item().

invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor

(

)

const

Definition at line 3335 of file game.cpp.

{
    shared_ptr_fast<ui_adaptor> ui = main_ui_adaptor.lock();
    if( ui ) {
        ui->invalidate_ui();
    }
}

References main_ui_adaptor.

Referenced by add_draw_callback(), cancel_activity_or_ignore_query(), cancel_activity_query(), do_turn(), fling_creature(), get_player_input(), list_items(), list_monsters(), look_around(), and zones_manager().

inventory_item_menu()

int game::inventory_item_menu	(	item_location	locThisItem,
		const std::function< int()> &	startx = []() { return 0; },
		const std::function< int()> &	width = []() { return 50; },
		inventory_item_menu_positon	position = RIGHT_OF_INFO
	)

Definition at line 2085 of file game.cpp.

{
    int cMenu = static_cast<int>( '+' );
 
    item &oThisItem = *locThisItem;
    if( u.has_item( oThisItem ) ) {
#if defined(__ANDROID__)
        if( get_option<bool>( "ANDROID_INVENTORY_AUTOADD" ) ) {
            add_key_to_quick_shortcuts( oThisItem.invlet, "INVENTORY", false );
        }
#endif
 
        std::vector<iteminfo> vThisItem;
        std::vector<iteminfo> vDummy;
 
        const bool bHPR = get_auto_pickup().has_rule( &oThisItem );
        const bool cant_unwield_weapon = u.weapon.has_flag( "NO_UNWIELD" );
        const bool cant_drop_this = cant_unwield_weapon && u.is_wielding( oThisItem );
        const hint_rating rate_wield_item = cant_unwield_weapon ? hint_rating::cant :
                                            hint_rating::good;
        const hint_rating rate_drop_item = cant_drop_this ? hint_rating::cant :
                                           hint_rating::good;
 
        uilist action_menu;
        action_menu.allow_anykey = true;
        const auto addentry = [&]( const char key, const std::string & text, const hint_rating hint ) {
            // The char is used as retval from the uilist *and* as hotkey.
            action_menu.addentry( key, true, key, text );
            auto &entry = action_menu.entries.back();
            switch( hint ) {
                case hint_rating::cant:
                    entry.text_color = c_light_gray;
                    break;
                case hint_rating::iffy:
                    entry.text_color = c_light_red;
                    break;
                case hint_rating::good:
                    entry.text_color = c_light_green;
                    break;
            }
        };
        addentry( 'a', pgettext( "action", "activate" ), u.rate_action_use( oThisItem ) );
        addentry( 'R', pgettext( "action", "read" ), u.rate_action_read( oThisItem ) );
        addentry( 'E', pgettext( "action", "eat" ), u.rate_action_eat( oThisItem ) );
        addentry( 'W', pgettext( "action", "wear" ), u.rate_action_wear( oThisItem ) );
        addentry( 'w', pgettext( "action", "wield" ), rate_wield_item );
        addentry( 't', pgettext( "action", "throw" ), rate_drop_item );
        addentry( 'c', pgettext( "action", "change side" ), u.rate_action_change_side( oThisItem ) );
        addentry( 'T', pgettext( "action", "take off" ), u.rate_action_takeoff( oThisItem ) );
        addentry( 'd', pgettext( "action", "drop" ), rate_drop_item );
        addentry( 'U', pgettext( "action", "unload" ), u.rate_action_unload( oThisItem ) );
        addentry( 'r', pgettext( "action", "reload" ), u.rate_action_reload( oThisItem ) );
        addentry( 'p', pgettext( "action", "part reload" ), u.rate_action_reload( oThisItem ) );
        addentry( 'm', pgettext( "action", "mend" ), u.rate_action_mend( oThisItem ) );
        addentry( 'D', pgettext( "action", "disassemble" ), u.rate_action_disassemble( oThisItem ) );
 
        if( oThisItem.is_favorite ) {
            addentry( 'f', pgettext( "action", "unfavorite" ), hint_rating::good );
        } else {
            addentry( 'f', pgettext( "action", "favorite" ), hint_rating::good );
        }
 
        addentry( '=', pgettext( "action", "reassign" ), hint_rating::good );
 
        if( bHPR ) {
            addentry( '-', _( "Autopickup" ), hint_rating::iffy );
        } else {
            addentry( '+', _( "Autopickup" ), hint_rating::good );
        }
 
        int iScrollPos = 0;
        oThisItem.info( true, vThisItem );
 
        action_menu.w_y_setup = 0;
        action_menu.w_x_setup = [&]( const int popup_width ) -> int {
            switch( position )
            {
                default:
                case RIGHT_TERMINAL_EDGE:
                    return 0;
                case LEFT_OF_INFO:
                    return iStartX() - popup_width;
                case RIGHT_OF_INFO:
                    return iStartX() + iWidth();
                case LEFT_TERMINAL_EDGE:
                    return TERMX - popup_width;
            }
        };
        // Filtering isn't needed, the number of entries is manageable.
        action_menu.filtering = false;
        // Default menu border color is different, this matches the border of the item info window.
        action_menu.border_color = BORDER_COLOR;
 
        item_info_data data( oThisItem.tname(), oThisItem.type_name(), vThisItem, vDummy, iScrollPos );
        data.without_getch = true;
 
        catacurses::window w_info;
        int iScrollHeight = 0;
 
        std::unique_ptr<ui_adaptor> ui = std::make_unique<ui_adaptor>();
        ui->on_screen_resize( [&]( ui_adaptor & ui ) {
            w_info = catacurses::newwin( TERMY, iWidth(), point( iStartX(), 0 ) );
            iScrollHeight = TERMY - 2;
            ui.position_from_window( w_info );
        } );
        ui->mark_resize();
 
        ui->on_redraw( [&]( const ui_adaptor & ) {
            draw_item_info( w_info, data );
        } );
 
        bool exit = false;
        do {
            const int prev_selected = action_menu.selected;
            action_menu.query( false );
            if( action_menu.ret >= 0 ) {
                cMenu = action_menu.ret; /* Remember: hotkey == retval, see addentry above. */
            } else if( action_menu.ret == UILIST_UNBOUND && action_menu.keypress == KEY_RIGHT ) {
                // Simulate KEY_RIGHT == '\n' (confirm currently selected entry) for compatibility with old version.
                // TODO: ideally this should be done in the uilist, maybe via a callback.
                cMenu = action_menu.ret = action_menu.entries[action_menu.selected].retval;
            } else if( action_menu.keypress == KEY_PPAGE || action_menu.keypress == KEY_NPAGE ) {
                cMenu = action_menu.keypress;
                // Prevent the menu from scrolling with this key. TODO: Ideally the menu
                // could be instructed to ignore these two keys instead of scrolling.
                action_menu.selected = prev_selected;
                action_menu.fselected = prev_selected;
                action_menu.vshift = 0;
            } else {
                cMenu = 0;
            }
 
            if( action_menu.ret != UILIST_WAIT_INPUT && action_menu.ret != UILIST_UNBOUND ) {
                exit = true;
                ui = nullptr;
            }
 
            switch( cMenu ) {
                case 'a':
                    avatar_action::use_item( u, locThisItem );
                    break;
                case 'E':
                    avatar_action::eat( u, locThisItem );
                    break;
                case 'W':
                    u.wear( oThisItem );
                    break;
                case 'w':
                    wield( locThisItem );
                    break;
                case 't':
                    avatar_action::plthrow( u, locThisItem );
                    break;
                case 'c':
                    u.change_side( locThisItem );
                    break;
                case 'T':
                    u.takeoff( oThisItem );
                    break;
                case 'd':
                    u.drop( locThisItem, u.pos() );
                    break;
                case 'U':
                    unload( locThisItem );
                    break;
                case 'r':
                    reload( locThisItem );
                    break;
                case 'p':
                    reload( locThisItem, true );
                    break;
                case 'm':
                    avatar_action::mend( u, locThisItem );
                    break;
                case 'R':
                    u.read( locThisItem );
                    break;
                case 'D':
                    u.disassemble( locThisItem, false );
                    break;
                case 'f':
                    oThisItem.is_favorite = !oThisItem.is_favorite;
                    break;
                case '=':
                    game_menus::inv::reassign_letter( u, oThisItem );
                    break;
                case KEY_PPAGE:
                    iScrollPos -= iScrollHeight;
                    if( ui ) {
                        ui->invalidate_ui();
                    }
                    break;
                case KEY_NPAGE:
                    iScrollPos += iScrollHeight;
                    if( ui ) {
                        ui->invalidate_ui();
                    }
                    break;
                case '+':
                    if( !bHPR ) {
                        get_auto_pickup().add_rule( &oThisItem );
                        add_msg( m_info, _( "'%s' added to character pickup rules." ), oThisItem.tname( 1,
                                 false ) );
                    }
                    break;
                case '-':
                    if( bHPR ) {
                        get_auto_pickup().remove_rule( &oThisItem );
                        add_msg( m_info, _( "'%s' removed from character pickup rules." ), oThisItem.tname( 1,
                                 false ) );
                    }
                    break;
                default:
                    break;
            }
        } while( !exit );
    }
    return cMenu;
}

References _, add_msg(), auto_pickup::player_settings::add_rule(), uilist::addentry(), uilist::allow_anykey, BORDER_COLOR, uilist::border_color, c_light_gray, c_light_green, c_light_red, cant, Character::change_side(), player::disassemble(), draw_item_info(), Character::drop(), avatar_action::eat(), uilist::entries, uilist::filtering, uilist::fselected, get_auto_pickup(), good, item::has_flag(), visitable< T >::has_item(), auto_pickup::player_settings::has_rule(), iffy, item::info(), item::invlet, item::is_favorite, Character::is_wielding(), KEY_NPAGE, KEY_PPAGE, KEY_RIGHT, uilist::keypress, LEFT_OF_INFO, LEFT_TERMINAL_EDGE, m_info, avatar_action::mend(), catacurses::newwin(), pgettext(), avatar_action::plthrow(), Character::pos(), uilist::query(), Character::rate_action_change_side(), player::rate_action_disassemble(), Character::rate_action_eat(), player::rate_action_mend(), avatar::rate_action_read(), player::rate_action_reload(), player::rate_action_takeoff(), player::rate_action_unload(), player::rate_action_use(), player::rate_action_wear(), avatar::read(), game_menus::inv::reassign_letter(), reload(), auto_pickup::player_settings::remove_rule(), uilist::ret, RIGHT_OF_INFO, RIGHT_TERMINAL_EDGE, uilist::selected, player::takeoff(), TERMX, TERMY, item::tname(), item::type_name(), u, UILIST_UNBOUND, UILIST_WAIT_INPUT, unload(), avatar_action::use_item(), uilist::vshift, uilist::w_x_setup, uilist::w_y_setup, Character::weapon, player::wear(), wield(), and item_info_data::without_getch.

is_core_data_loaded()

bool game::is_core_data_loaded

(

)

const

Returns whether the core data is currently loaded.

Definition at line 430 of file game.cpp.

{
    return DynamicDataLoader::get_instance().is_data_finalized();
}

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

is_dangerous_tile()

bool game::is_dangerous_tile

(

const tripoint &

dest_loc

)

const

Definition at line 9241 of file game.cpp.

{
    return !( get_dangerous_tile( dest_loc ).empty() );
}

References get_dangerous_tile().

Referenced by walk_move().

is_empty()

bool game::is_empty

(

const tripoint &

p

)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 5137 of file game.cpp.

{
    return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
           critter_at( p ) == nullptr;
}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

is_game_over()

bool game::is_game_over ( )

private

Definition at line 2675 of file game.cpp.

{
    if( uquit == QUIT_WATCH ) {
        // deny player movement and dodging
        u.moves = 0;
        // prevent pain from updating
        u.set_pain( 0 );
        // prevent dodging
        u.dodges_left = 0;
        return false;
    }
    if( uquit == QUIT_DIED ) {
        if( u.in_vehicle ) {
            m.unboard_vehicle( u.pos() );
        }
        u.place_corpse();
        return true;
    }
    if( uquit == QUIT_SUICIDE ) {
        if( u.in_vehicle ) {
            m.unboard_vehicle( u.pos() );
        }
        return true;
    }
    if( uquit != QUIT_NO ) {
        return true;
    }
    // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
    if( u.is_dead_state() ) {
        Messages::deactivate();
        if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
            uquit = QUIT_WATCH;
        } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
            uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
                    QUIT_WATCH : QUIT_DIED;
        } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
            uquit = QUIT_DIED;
        } else {
            // Something funky happened here, just die.
            dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
            uquit = QUIT_DIED;
        }
        return is_game_over();
    }
    return false;
}

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

is_hostile_nearby()

Creature * game::is_hostile_nearby

(

)

Definition at line 3934 of file game.cpp.

{
    int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
                   get_option<int>( "SAFEMODEPROXIMITY" );
    return is_hostile_within( distance );
}

References is_hostile_within(), and MAX_VIEW_DISTANCE.

is_hostile_very_close()

Creature * game::is_hostile_very_close

(

)

Definition at line 3941 of file game.cpp.

{
    return is_hostile_within( DANGEROUS_PROXIMITY );
}

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

is_hostile_within()

Creature * game::is_hostile_within ( int  distance )

private

Definition at line 3946 of file game.cpp.

{
    for( auto &critter : u.get_visible_creatures( distance ) ) {
        if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
            return critter;
        }
    }
 
    return nullptr;
}

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

is_in_sunlight()

bool game::is_in_sunlight

(

const tripoint &

p

)

Returns true if p is outdoors and it is sunny.

Definition at line 5143 of file game.cpp.

{
    return weather::is_in_sunlight( m, p, get_weather().weather_id );
}

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

is_in_viewport()

bool game::is_in_viewport	(	const tripoint &	p,
		int	margin = 0
	)		const

Definition at line 3580 of file game.cpp.

{
    const tripoint diff( u.pos() + u.view_offset - p );
 
    return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
           ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

is_sheltered()

bool game::is_sheltered

(

const tripoint &

p

)

Returns true if p is indoors, underground, or in a car.

Definition at line 5148 of file game.cpp.

{
    return weather::is_sheltered( m, p );
}

References weather::is_sheltered(), and m.

is_zones_manager_open()

bool game::is_zones_manager_open

(

)

const

Definition at line 6290 of file game.cpp.

{
    return zones_manager_open;
}

References zones_manager_open.

item_action_menu()

void game::item_action_menu ( )

private

Definition at line 231 of file item_action.cpp.

{
    const auto &gen = item_action_generator::generator();
    const action_map &item_actions = gen.get_item_action_map();
 
    // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
    std::vector<item *> pseudos;
    item toolset( "toolset", calendar::turn );
    if( u.has_active_bionic( bio_tools ) ) {
        pseudos.push_back( &toolset );
    }
    item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
    if( u.has_active_bionic( bio_claws ) ) {
        pseudos.push_back( &bio_claws_item );
    }
 
    item_action_map iactions = gen.map_actions_to_items( u, pseudos );
    if( iactions.empty() ) {
        popup( _( "You don't have any items with registered uses" ) );
    }
 
    uilist kmenu;
    kmenu.text = _( "Execute which action?" );
    kmenu.input_category = "ITEM_ACTIONS";
    input_context ctxt( "ITEM_ACTIONS" );
    for( const auto &id : item_actions ) {
        ctxt.register_action( id.first, id.second.name );
        kmenu.additional_actions.emplace_back( id.first, id.second.name );
    }
    actmenu_cb callback( item_actions );
    kmenu.callback = &callback;
    int num = 0;
 
    const auto assigned_action = [&iactions]( const item_action_id & action ) {
        return iactions.find( action ) != iactions.end();
    };
 
    std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
    // Sorts menu items by action.
    using Iter = decltype( menu_items )::iterator;
    const auto sort_menu = []( Iter from, Iter to ) {
        std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
        const std::tuple<item_action_id, std::string, std::string> &rhs ) {
            return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
        } );
    };
    // Add mapped actions to the menu vector.
    std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
    []( const std::pair<item_action_id, item *> &elem ) {
        std::string ss = elem.second->display_name();
        if( elem.second->ammo_required() ) {
            ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
        }
 
        const auto method = elem.second->get_use( elem.first );
        if( method ) {
            return std::make_tuple( method->get_type(), method->get_name(), ss );
        } else {
            return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
        }
    } );
    // Sort mapped actions.
    sort_menu( menu_items.begin(), menu_items.end() );
    // Add unmapped but binded actions to the menu vector.
    for( const auto &elem : item_actions ) {
        if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
            menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
        }
    }
    // Sort unmapped actions.
    auto iter = menu_items.begin();
    std::advance( iter, iactions.size() );
    sort_menu( iter, menu_items.end() );
    // Determine max lengths, to print the menu nicely.
    std::pair<int, int> max_len;
    for( const auto &elem : menu_items ) {
        max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
        max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
    }
    // Fill the menu.
    for( const auto &elem : menu_items ) {
        std::string ss;
        ss += std::get<1>( elem );
        ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
        ss += std::string( 4, ' ' );
 
        ss += std::get<2>( elem );
        ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
 
        const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
        const bool enabled = assigned_action( std::get<0>( elem ) );
 
        kmenu.addentry( num, enabled, bind, ss );
        num++;
    }
 
    kmenu.query();
    if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
        return;
    }
 
    const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
    item *it = iactions[action];
 
    u.invoke_item( it, action );
 
    u.inv.restack( u );
    u.inv.unsort();
}

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

knockback() [1/2]

void game::knockback	(	const tripoint &	s,
		const tripoint &	t,
		int	force,
		int	stun,
		int	dam_mult
	)

Definition at line 4570 of file game.cpp.

{
    std::vector<tripoint> traj;
    traj.clear();
    traj = line_to( s, t, 0, 0 );
    traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
    traj = continue_line( traj, force );
    traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
 
    knockback( traj, stun, dam_mult );
}

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

knockback() [2/2]

void game::knockback	(	std::vector< tripoint > &	traj,
		int	stun,
		int	dam_mult
	)

Definition at line 4586 of file game.cpp.

{
    // TODO: make the force parameter actually do something.
    // the header file says higher force causes more damage.
    // perhaps that is what it should do?
    tripoint tp = traj.front();
    if( !critter_at( tp ) ) {
        debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
        return;
    }
    std::size_t force_remaining = traj.size();
    if( monster *const targ = critter_at<monster>( tp, true ) ) {
        if( stun > 0 ) {
            targ->add_effect( effect_stunned, 1_turns * stun );
            add_msg( _( "%s was stunned!" ), targ->name() );
        }
        for( size_t i = 1; i < traj.size(); i++ ) {
            if( m.impassable( traj[i].xy() ) ) {
                targ->setpos( traj[i - 1] );
                force_remaining = traj.size() - i;
                if( stun != 0 ) {
                    targ->add_effect( effect_stunned, 1_turns * force_remaining );
                    add_msg( _( "%s was stunned!" ), targ->name() );
                    add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
                    targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
                    targ->check_dead_state();
                }
                m.bash( traj[i], 2 * dam_mult * force_remaining );
                break;
            } else if( critter_at( traj[i] ) ) {
                targ->setpos( traj[i - 1] );
                force_remaining = traj.size() - i;
                if( stun != 0 ) {
                    targ->add_effect( effect_stunned, 1_turns * force_remaining );
                    add_msg( _( "%s was stunned!" ), targ->name() );
                }
                traj.erase( traj.begin(), traj.begin() + i );
                if( critter_at<monster>( traj.front() ) ) {
                    add_msg( _( "%s collided with something else and sent it flying!" ),
                             targ->name() );
                } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
                    if( guy->male ) {
                        add_msg( _( "%s collided with someone else and sent him flying!" ),
                                 targ->name() );
                    } else {
                        add_msg( _( "%s collided with someone else and sent her flying!" ),
                                 targ->name() );
                    }
                } else if( u.pos() == traj.front() ) {
                    add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
                }
                knockback( traj, stun, dam_mult );
                break;
            }
            targ->setpos( traj[i] );
            if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
                targ->die( nullptr );
                if( u.sees( *targ ) ) {
                    add_msg( _( "The %s drowns!" ), targ->name() );
                }
            }
            if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
                !targ->is_dead() ) {
                targ->die( nullptr );
                if( u.sees( *targ ) ) {
                    add_msg( _( "The %s flops around and dies!" ), targ->name() );
                }
            }
        }
    } else if( npc *const targ = critter_at<npc>( tp ) ) {
        if( stun > 0 ) {
            targ->add_effect( effect_stunned, 1_turns * stun );
            add_msg( _( "%s was stunned!" ), targ->name );
        }
        for( size_t i = 1; i < traj.size(); i++ ) {
            if( m.impassable( traj[i].xy() ) ) { // oops, we hit a wall!
                targ->setpos( traj[i - 1] );
                force_remaining = traj.size() - i;
                if( stun != 0 ) {
                    targ->add_effect( effect_stunned, 1_turns * force_remaining );
                    if( targ->has_effect( effect_stunned ) ) {
                        add_msg( _( "%s was stunned!" ), targ->name );
                    }
 
                    std::array<bodypart_id, 8> bps = {{
                            bodypart_id( "head" ),
                            bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
                            bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
                            bodypart_id( "torso" ),
                            bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
                        }
                    };
                    for( const bodypart_id &bp : bps ) {
                        if( one_in( 2 ) ) {
                            targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
                        }
                    }
                    targ->check_dead_state();
                }
                m.bash( traj[i], 2 * dam_mult * force_remaining );
                break;
            } else if( critter_at( traj[i] ) ) {
                targ->setpos( traj[i - 1] );
                force_remaining = traj.size() - i;
                if( stun != 0 ) {
                    add_msg( _( "%s was stunned!" ), targ->name );
                    targ->add_effect( effect_stunned, 1_turns * force_remaining );
                }
                traj.erase( traj.begin(), traj.begin() + i );
                const tripoint &traj_front = traj.front();
                if( critter_at<monster>( traj_front ) ) {
                    add_msg( _( "%s collided with something else and sent it flying!" ),
                             targ->name );
                } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
                    if( guy->male ) {
                        add_msg( _( "%s collided with someone else and sent him flying!" ),
                                 targ->name );
                    } else {
                        add_msg( _( "%s collided with someone else and sent her flying!" ),
                                 targ->name );
                    }
                } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
                           ( u.has_trait( trait_LEG_TENT_BRACE ) && ( !u.footwear_factor() ||
                                   ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
                    add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
                } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
                    add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
                }
                knockback( traj, stun, dam_mult );
                break;
            }
            targ->setpos( traj[i] );
        }
    } else if( u.pos() == tp ) {
        if( stun > 0 ) {
            u.add_effect( effect_stunned, 1_turns * stun );
            add_msg( m_bad, vgettext( "You were stunned for %d turn!",
                                      "You were stunned for %d turns!",
                                      stun ),
                     stun );
        }
        for( size_t i = 1; i < traj.size(); i++ ) {
            if( m.impassable( traj[i] ) ) { // oops, we hit a wall!
                u.setpos( traj[i - 1] );
                force_remaining = traj.size() - i;
                if( stun != 0 ) {
                    if( u.has_effect( effect_stunned ) ) {
                        add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
                                                  "You were stunned AGAIN for %d turns!",
                                                  force_remaining ),
                                 force_remaining );
                    } else {
                        add_msg( m_bad, vgettext( "You were stunned for %d turn!",
                                                  "You were stunned for %d turns!",
                                                  force_remaining ),
                                 force_remaining );
                    }
                    u.add_effect( effect_stunned, 1_turns * force_remaining );
                    std::array<bodypart_id, 8> bps = {{
                            bodypart_id( "head" ),
                            bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
                            bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
                            bodypart_id( "torso" ),
                            bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
                        }
                    };
                    for( const bodypart_id &bp : bps ) {
                        if( one_in( 2 ) ) {
                            u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
                        }
                    }
                    u.check_dead_state();
                }
                m.bash( traj[i], 2 * dam_mult * force_remaining );
                break;
            } else if( critter_at( traj[i] ) ) {
                u.setpos( traj[i - 1] );
                force_remaining = traj.size() - i;
                if( stun != 0 ) {
                    if( u.has_effect( effect_stunned ) ) {
                        add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
                                                  "You were stunned AGAIN for %d turns!",
                                                  force_remaining ),
                                 force_remaining );
                    } else {
                        add_msg( m_bad, vgettext( "You were stunned for %d turn!",
                                                  "You were stunned for %d turns!",
                                                  force_remaining ),
                                 force_remaining );
                    }
                    u.add_effect( effect_stunned, 1_turns * force_remaining );
                }
                traj.erase( traj.begin(), traj.begin() + i );
                if( critter_at<monster>( traj.front() ) ) {
                    add_msg( _( "You collided with something and sent it flying!" ) );
                } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
                    if( guy->male ) {
                        add_msg( _( "You collided with someone and sent him flying!" ) );
                    } else {
                        add_msg( _( "You collided with someone and sent her flying!" ) );
                    }
                }
                knockback( traj, stun, dam_mult );
                break;
            }
            if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
                avatar_action::swim( m, u, u.pos() );
            } else {
                u.setpos( traj[i] );
            }
        }
    }
}

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

light_level()

unsigned char game::light_level

(

int

zlev

)

const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3913 of file game.cpp.

{
    const float light = natural_light_level( zlev );
    return LIGHT_RANGE( light );
}

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

list_active_characters()

std::vector< std::string > game::list_active_characters

(

)

Returns a list of currently active character saves.

Definition at line 3120 of file game.cpp.

{
    std::vector<std::string> saves;
    for( auto &worldsave : world_generator->active_world->world_saves ) {
        saves.push_back( worldsave.player_name() );
    }
    return saves;
}

References world_generator.

Referenced by cleanup_at_end().

list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list )

private

Definition at line 7524 of file game.cpp.

{
    std::vector<map_item_stack> ground_items = item_list;
    int iInfoHeight = 0;
    int iMaxRows = 0;
    int width = 0;
    int max_name_width = 0;
 
    //find max length of item name and resize window width
    for( const map_item_stack &cur_item : ground_items ) {
        const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
        if( item_len > max_name_width ) {
            max_name_width = item_len;
        }
    }
 
    tripoint active_pos;
    map_item_stack *activeItem = nullptr;
 
    catacurses::window w_items;
    catacurses::window w_items_border;
    catacurses::window w_item_info;
 
    ui_adaptor ui;
    ui.on_screen_resize( [&]( ui_adaptor & ui ) {
        iInfoHeight = std::min( 25, TERMY / 2 );
        iMaxRows = TERMY - iInfoHeight - 2;
 
        width = clamp( max_name_width, 45, TERMX / 3 );
 
        const int offsetX = TERMX - width;
 
        w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
                                      width - 2, point( offsetX + 1, 1 ) );
        w_items_border = catacurses::newwin( TERMY - iInfoHeight,
                                             width, point( offsetX, 0 ) );
        w_item_info = catacurses::newwin( iInfoHeight, width,
                                          point( offsetX, TERMY - iInfoHeight ) );
 
        if( activeItem ) {
            centerlistview( active_pos, width );
        }
 
        ui.position( point( offsetX, 0 ), point( width, TERMY ) );
    } );
    ui.mark_resize();
 
    // use previously selected sorting method
    bool sort_radius = uistate.list_item_sort != 2;
    bool addcategory = !sort_radius;
 
    // reload filter/priority settings on the first invocation, if they were active
    if( !uistate.list_item_init ) {
        if( uistate.list_item_filter_active ) {
            sFilter = uistate.list_item_filter;
        }
        if( uistate.list_item_downvote_active ) {
            list_item_downvote = uistate.list_item_downvote;
        }
        if( uistate.list_item_priority_active ) {
            list_item_upvote = uistate.list_item_priority;
        }
        uistate.list_item_init = true;
    }
 
    //this stores only those items that match our filter
    std::vector<map_item_stack> filtered_items =
        !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
    int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
    int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
    int iItemNum = ground_items.size();
 
    const tripoint stored_view_offset = u.view_offset;
 
    u.view_offset = tripoint_zero;
 
    int iActive = 0; // Item index that we're looking at
    bool refilter = true;
    int page_num = 0;
    int iCatSortNum = 0;
    int iScrollPos = 0;
    std::map<int, std::string> mSortCategory;
 
    std::string action;
    input_context ctxt( "LIST_ITEMS" );
    ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
    ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
    ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
    ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
    ctxt.register_action( "PAGE_DOWN" );
    ctxt.register_action( "PAGE_UP" );
    ctxt.register_action( "NEXT_TAB" );
    ctxt.register_action( "PREV_TAB" );
    ctxt.register_action( "HELP_KEYBINDINGS" );
    ctxt.register_action( "QUIT" );
    ctxt.register_action( "FILTER" );
    ctxt.register_action( "RESET_FILTER" );
    ctxt.register_action( "EXAMINE" );
    ctxt.register_action( "COMPARE" );
    ctxt.register_action( "PRIORITY_INCREASE" );
    ctxt.register_action( "PRIORITY_DECREASE" );
    ctxt.register_action( "SORT" );
    ctxt.register_action( "TRAVEL_TO" );
 
    cata::optional<item_filter_type> filter_type;
 
    ui.on_redraw( [&]( const ui_adaptor & ) {
        reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
 
        if( ground_items.empty() ) {
            wnoutrefresh( w_items_border );
            mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
        } else {
            int iStartPos = 0;
            werase( w_items );
            calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
            int iNum = 0;
            bool high = false;
            bool low = false;
            int index = 0;
            int iCatSortOffset = 0;
 
            for( int i = 0; i < iStartPos; i++ ) {
                if( !mSortCategory[i].empty() ) {
                    iNum++;
                }
            }
            for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
                if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
                    high = true;
                    low = false;
                } else if( index >= lowPStart + iCatSortOffset ) {
                    high = false;
                    low = true;
                } else {
                    high = false;
                    low = false;
                }
 
                if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
                    int iThisPage = 0;
                    if( !mSortCategory[iNum].empty() ) {
                        iCatSortOffset++;
                        mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
                    } else {
                        if( iNum == iActive ) {
                            iThisPage = page_num;
                        }
                        std::string sText;
                        if( iter->vIG.size() > 1 ) {
                            sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
                        }
                        sText += iter->example->tname();
                        if( iter->vIG[iThisPage].count > 1 ) {
                            sText += string_format( "[%d]", iter->vIG[iThisPage].count );
                        }
 
                        nc_color col = c_light_green;
                        if( iNum != iActive ) {
                            if( high ) {
                                col = c_yellow;
                            } else if( low ) {
                                col = c_red;
                            } else {
                                col = iter->example->color_in_inventory();
                            }
                        }
                        trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
                        const int numw = iItemNum > 9 ? 2 : 1;
                        const int x = iter->vIG[iThisPage].pos.x;
                        const int y = iter->vIG[iThisPage].pos.y;
                        mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
                                   iNum == iActive ? c_light_green : c_light_gray,
                                   "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
                                   direction_name_short( direction_from( point_zero, point( x, y ) ) ) );
                        ++iter;
                    }
                } else {
                    ++iter;
                }
                iNum++;
            }
            iNum = 0;
            for( int i = 0; i < iActive; i++ ) {
                if( !mSortCategory[i].empty() ) {
                    iNum++;
                }
            }
            mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
                       c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
            wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
            werase( w_item_info );
 
            if( iItemNum > 0 && activeItem ) {
                std::vector<iteminfo> vThisItem;
                std::vector<iteminfo> vDummy;
                activeItem->example->info( true, vThisItem );
 
                item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
                dummy.without_getch = true;
                dummy.without_border = true;
 
                draw_item_info( w_item_info, dummy );
            }
            draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
            wnoutrefresh( w_items_border );
        }
 
        const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
        draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
 
        if( iItemNum > 0 && activeItem ) {
            // print info window title: < item name >
            mvwprintw( w_item_info, point( 2, 0 ), "< " );
            trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
                            activeItem->example->display_name() );
            wprintw( w_item_info, " >" );
        }
 
        wnoutrefresh( w_items );
        wnoutrefresh( w_item_info );
 
        if( filter_type ) {
            draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
        }
    } );
 
    cata::optional<tripoint> trail_start;
    cata::optional<tripoint> trail_end;
    bool trail_end_x = false;
    shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
            trail_end_x );
    add_draw_callback( trail_cb );
 
    do {
        if( action == "COMPARE" && activeItem ) {
            game_menus::inv::compare( u, active_pos );
        } else if( action == "FILTER" ) {
            filter_type = item_filter_type::FILTER;
            ui.invalidate_ui();
            string_input_popup()
            .title( _( "Filter:" ) )
            .width( 55 )
            .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
            .identifier( "item_filter" )
            .max_length( 256 )
            .edit( sFilter );
            refilter = true;
            addcategory = !sort_radius;
            uistate.list_item_filter_active = !sFilter.empty();
            filter_type = cata::nullopt;
        } else if( action == "RESET_FILTER" ) {
            sFilter.clear();
            filtered_items = ground_items;
            refilter = true;
            uistate.list_item_filter_active = false;
            addcategory = !sort_radius;
        } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
            std::vector<iteminfo> vThisItem;
            std::vector<iteminfo> vDummy;
            activeItem->example->info( true, vThisItem );
 
            item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
                                      vDummy );
            info_data.handle_scrolling = true;
 
            draw_item_info( [&]() -> catacurses::window {
                return catacurses::newwin( TERMY, width - 5, point_zero );
            }, info_data );
        } else if( action == "PRIORITY_INCREASE" ) {
            filter_type = item_filter_type::HIGH_PRIORITY;
            ui.invalidate_ui();
            list_item_upvote = string_input_popup()
                               .title( _( "High Priority:" ) )
                               .width( 55 )
                               .text( list_item_upvote )
                               .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
                               .identifier( "list_item_priority" )
                               .max_length( 256 )
                               .query_string();
            refilter = true;
            addcategory = !sort_radius;
            uistate.list_item_priority_active = !list_item_upvote.empty();
            filter_type = cata::nullopt;
        } else if( action == "PRIORITY_DECREASE" ) {
            filter_type = item_filter_type::LOW_PRIORITY;
            ui.invalidate_ui();
            list_item_downvote = string_input_popup()
                                 .title( _( "Low Priority:" ) )
                                 .width( 55 )
                                 .text( list_item_downvote )
                                 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
                                 .identifier( "list_item_downvote" )
                                 .max_length( 256 )
                                 .query_string();
            refilter = true;
            addcategory = !sort_radius;
            uistate.list_item_downvote_active = !list_item_downvote.empty();
            filter_type = cata::nullopt;
        } else if( action == "SORT" ) {
            if( sort_radius ) {
                sort_radius = false;
                addcategory = true;
                uistate.list_item_sort = 2; // list is sorted by category
            } else {
                sort_radius = true;
                uistate.list_item_sort = 1; // list is sorted by distance
            }
            highPEnd = -1;
            lowPStart = -1;
            iCatSortNum = 0;
 
            mSortCategory.clear();
            refilter = true;
        } else if( action == "TRAVEL_TO" && activeItem ) {
            if( !u.sees( u.pos() + active_pos ) ) {
                add_msg( _( "You can't see that destination." ) );
            }
            auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
                                  u.get_path_avoid() );
            if( route.size() > 1 ) {
                route.pop_back();
                u.set_destination( route );
                break;
            } else {
                add_msg( m_info, _( "You can't travel there." ) );
            }
        }
        if( uistate.list_item_sort == 1 ) {
            ground_items = item_list;
        } else if( uistate.list_item_sort == 2 ) {
            std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
        }
 
        if( refilter ) {
            refilter = false;
            filtered_items = filter_item_stacks( ground_items, sFilter );
            highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
            lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
            iActive = 0;
            page_num = 0;
            iItemNum = filtered_items.size();
        }
 
        if( addcategory ) {
            addcategory = false;
            iCatSortNum = 0;
            mSortCategory.clear();
            if( highPEnd > 0 ) {
                mSortCategory[0] = _( "HIGH PRIORITY" );
                iCatSortNum++;
            }
            std::string last_cat_name;
            for( int i = std::max( 0, highPEnd );
                 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
                const std::string &cat_name = filtered_items[i].example->get_category().name();
                if( cat_name != last_cat_name ) {
                    mSortCategory[i + iCatSortNum++] = cat_name;
                    last_cat_name = cat_name;
                }
            }
            if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
                mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
            }
            if( !mSortCategory[0].empty() ) {
                iActive++;
            }
            iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
        }
 
        if( action == "UP" ) {
            do {
                iActive--;
 
            } while( !mSortCategory[iActive].empty() );
            iScrollPos = 0;
            page_num = 0;
            if( iActive < 0 ) {
                iActive = iItemNum - 1;
            }
        } else if( action == "DOWN" ) {
            do {
                iActive++;
 
            } while( !mSortCategory[iActive].empty() );
            iScrollPos = 0;
            page_num = 0;
            if( iActive >= iItemNum ) {
                iActive = mSortCategory[0].empty() ? 0 : 1;
            }
        } else if( action == "RIGHT" ) {
            if( !filtered_items.empty() && activeItem ) {
                if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
                    page_num = activeItem->vIG.size() - 1;
                }
            }
        } else if( action == "LEFT" ) {
            page_num = std::max( 0, page_num - 1 );
        } else if( action == "PAGE_UP" ) {
            iScrollPos--;
        } else if( action == "PAGE_DOWN" ) {
            iScrollPos++;
        } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
            u.view_offset = stored_view_offset;
            return game::vmenu_ret::CHANGE_TAB;
        }
 
        active_pos = tripoint_zero;
        activeItem = nullptr;
 
        if( mSortCategory[iActive].empty() ) {
            auto iter = filtered_items.begin();
            for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
                if( mSortCategory[iNum].empty() ) {
                    ++iter;
                }
            }
            if( iter != filtered_items.end() ) {
                active_pos = iter->vIG[page_num].pos;
                activeItem = &( *iter );
            }
        }
 
        if( activeItem ) {
            centerlistview( active_pos, width );
            trail_start = u.pos();
            trail_end = u.pos() + active_pos;
            // Actually accessed from the terrain overlay callback `trail_cb` in the
            // call to `ui_manager::redraw`.
            //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            trail_end_x = true;
        } else {
            u.view_offset = stored_view_offset;
            trail_start = trail_end = cata::nullopt;
        }
        invalidate_main_ui_adaptor();
 
        ui_manager::redraw();
 
        action = ctxt.handle_input();
    } while( action != "QUIT" );
 
    u.view_offset = stored_view_offset;
    return game::vmenu_ret::QUIT;
}

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

list_items_monsters()

void game::list_items_monsters ( )

private

Definition at line 7479 of file game.cpp.

{
    std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
    // whole reality bubble
    const std::vector<map_item_stack> items = find_nearby_items( 60 );
 
    if( mons.empty() && items.empty() ) {
        add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
        return;
    }
 
    std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
        const auto att_lhs = lhs->attitude_to( u );
        const auto att_rhs = rhs->attitude_to( u );
 
        return att_lhs < att_rhs || ( att_lhs == att_rhs
                                      && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
    } );
 
    // If the current list is empty, switch to the non-empty list
    if( uistate.vmenu_show_items ) {
        if( items.empty() ) {
            uistate.vmenu_show_items = false;
        }
    } else if( mons.empty() ) {
        uistate.vmenu_show_items = true;
    }
 
    temp_exit_fullscreen();
    game::vmenu_ret ret;
    while( true ) {
        ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
        if( ret == game::vmenu_ret::CHANGE_TAB ) {
            uistate.vmenu_show_items = !uistate.vmenu_show_items;
        } else {
            break;
        }
    }
 
    if( ret == game::vmenu_ret::FIRE ) {
        avatar_action::fire_wielded_weapon( u );
    }
    reenter_fullscreen();
}

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

list_missions()

void game::list_missions

(

)

Definition at line 22 of file mission_ui.cpp.

{
    catacurses::window w_missions;
 
    enum class tab_mode : int {
        TAB_ACTIVE = 0,
        TAB_COMPLETED,
        TAB_FAILED,
        NUM_TABS,
        FIRST_TAB = 0,
        LAST_TAB = NUM_TABS - 1
    };
    tab_mode tab = tab_mode::FIRST_TAB;
    size_t selection = 0;
    int entries_per_page = 0;
    input_context ctxt( "MISSIONS" );
    ctxt.register_cardinal();
    ctxt.register_action( "CONFIRM" );
    ctxt.register_action( "QUIT" );
    ctxt.register_action( "HELP_KEYBINDINGS" );
 
    ui_adaptor ui;
    ui.on_screen_resize( [&]( ui_adaptor & ui ) {
        w_missions = new_centered_win( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH );
 
        // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
        entries_per_page = FULL_SCREEN_HEIGHT - 4;
 
        ui.position_from_window( w_missions );
    } );
    ui.mark_resize();
 
    std::vector<mission *> umissions;
 
    ui.on_redraw( [&]( const ui_adaptor & ) {
        werase( w_missions );
        // entries_per_page * page number
        const int top_of_page = entries_per_page * ( selection / entries_per_page );
        const int bottom_of_page =
            std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
 
        for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
            mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
        }
 
        const std::vector<std::pair<tab_mode, std::string>> tabs = {
            { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
            { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
            { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
        };
        draw_tabs( w_missions, tabs, tab );
        draw_border_below_tabs( w_missions );
 
        mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
                  tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
        mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
 
        draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
 
        for( int i = top_of_page; i <= bottom_of_page; i++ ) {
            const auto miss = umissions[i];
            const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
            const int y = i - top_of_page + 3;
            trim_and_print( w_missions, point( 1, y ), 28,
                            static_cast<int>( selection ) == i ? hilite( col ) : col,
                            miss->name() );
        }
 
        if( selection < umissions.size() ) {
            const auto miss = umissions[selection];
            const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
            std::string for_npc;
            if( miss->get_npc_id().is_valid() ) {
                npc *guy = g->find_npc( miss->get_npc_id() );
                if( guy ) {
                    for_npc = string_format( _( " for %s" ), guy->disp_name() );
                }
            }
 
            int y = 3;
            y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
                                 miss->name() + for_npc );
 
            auto format_tokenized_description = []( const std::string & description,
            const std::vector<std::pair<int, itype_id>> &rewards ) {
                std::string formatted_description = description;
                for( const auto &reward : rewards ) {
                    std::string token = "<reward_count:" + reward.second.str() + ">";
                    formatted_description = replace_all( formatted_description, token,
                                                         string_format( "%d", reward.first ) );
                }
                return formatted_description;
            };
 
            y++;
            if( !miss->get_description().empty() ) {
                y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
                                     format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
            }
            if( miss->has_deadline() ) {
                const time_point deadline = miss->get_deadline();
                mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
 
                if( tab != tab_mode::TAB_COMPLETED ) {
                    // There's no point in displaying this for a completed mission.
                    // @ TODO: But displaying when you completed it would be useful.
                    const time_duration remaining = deadline - calendar::turn;
                    std::string remaining_time;
 
                    if( remaining <= 0_turns ) {
                        remaining_time = _( "None!" );
                    } else if( u.has_watch() ) {
                        remaining_time = to_string( remaining );
                    } else {
                        remaining_time = to_string_approx( remaining );
                    }
 
                    mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
                }
            }
            if( miss->has_target() ) {
                const tripoint_abs_omt pos = u.global_omt_location();
                // TODO: target does not contain a z-component, targets are assumed to be on z=0
                mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s   You: %s" ),
                           miss->get_target().to_string(), pos.to_string() );
            }
        } else {
            static const std::map< tab_mode, std::string > nope = {
                { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
                { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
                { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
            };
            mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
        }
 
        wnoutrefresh( w_missions );
    } );
 
    while( true ) {
        umissions.clear();
        if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
            debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
            tab = tab_mode::FIRST_TAB;
        }
        switch( tab ) {
            case tab_mode::TAB_ACTIVE:
                umissions = u.get_active_missions();
                break;
            case tab_mode::TAB_COMPLETED:
                umissions = u.get_completed_missions();
                break;
            case tab_mode::TAB_FAILED:
                umissions = u.get_failed_missions();
                break;
            default:
                break;
        }
        if( ( !umissions.empty() && selection >= umissions.size() ) ||
            ( umissions.empty() && selection != 0 ) ) {
            debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
                      static_cast<int>( umissions.size() ) );
            selection = 0;
        }
        ui_manager::redraw();
        const std::string action = ctxt.handle_input();
        if( action == "RIGHT" ) {
            tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
            if( tab >= tab_mode::NUM_TABS ) {
                tab = tab_mode::FIRST_TAB;
            }
            selection = 0;
        } else if( action == "LEFT" ) {
            tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
            if( tab < tab_mode::FIRST_TAB ) {
                tab = tab_mode::LAST_TAB;
            }
            selection = 0;
        } else if( action == "DOWN" ) {
            selection++;
            if( selection >= umissions.size() ) {
                selection = 0;
            }
        } else if( action == "UP" ) {
            if( selection == 0 ) {
                selection = umissions.empty() ? 0 : umissions.size() - 1;
            } else {
                selection--;
            }
        } else if( action == "CONFIRM" ) {
            if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
                u.set_active_mission( *umissions[selection] );
            }
            break;
        } else if( action == "QUIT" ) {
            break;
        }
    }
}

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list )

private

Definition at line 7970 of file game.cpp.

{
    const int iInfoHeight = 15;
    const int width = 45;
    int offsetX = 0;
    int iMaxRows = 0;
 
    catacurses::window w_monsters;
    catacurses::window w_monsters_border;
    catacurses::window w_monster_info;
    catacurses::window w_monster_info_border;
 
    Creature *cCurMon = nullptr;
    tripoint iActivePos;
 
    bool hide_ui = false;
 
    ui_adaptor ui;
    ui.on_screen_resize( [&]( ui_adaptor & ui ) {
        if( hide_ui ) {
            ui.position( point_zero, point_zero );
        } else {
            offsetX = TERMX - width;
            iMaxRows = TERMY - iInfoHeight - 1;
 
            w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
                                             1 ) );
            w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
                                                    0 ) );
            w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
                                                 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
            w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
                                    TERMY - iInfoHeight ) );
 
            if( cCurMon ) {
                centerlistview( iActivePos, width );
            }
 
            ui.position( point( offsetX, 0 ), point( width, TERMY ) );
        }
    } );
    ui.mark_resize();
 
    const int max_gun_range = u.weapon.gun_range( &u );
 
    const tripoint stored_view_offset = u.view_offset;
    u.view_offset = tripoint_zero;
 
    int iActive = 0; // monster index that we're looking at
 
    std::string action;
    input_context ctxt( "LIST_MONSTERS" );
    ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
    ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
    ctxt.register_action( "NEXT_TAB" );
    ctxt.register_action( "PREV_TAB" );
    ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
    ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
    ctxt.register_action( "QUIT" );
    if( bVMonsterLookFire ) {
        ctxt.register_action( "look" );
        ctxt.register_action( "fire" );
    }
    ctxt.register_action( "HELP_KEYBINDINGS" );
 
    // first integer is the row the attitude category string is printed in the menu
    std::map<int, Creature::Attitude> mSortCategory;
 
    for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
        const auto attitude = monster_list[i]->attitude_to( u );
        if( attitude != last_attitude ) {
            mSortCategory[i + mSortCategory.size()] = attitude;
            last_attitude = attitude;
        }
    }
 
    ui.on_redraw( [&]( const ui_adaptor & ) {
        if( !hide_ui ) {
            draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
            draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
                                true );
 
            mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
            wprintz( w_monsters_border, c_white, _( "Monsters" ) );
 
            if( monster_list.empty() ) {
                werase( w_monsters );
                mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
                           _( "You don't see any monsters around you!" ) );
            } else {
                werase( w_monsters );
 
                const int iNumMonster = monster_list.size();
                const int iMenuSize = monster_list.size() + mSortCategory.size();
 
                const int numw = iNumMonster > 999 ? 4 :
                                 iNumMonster > 99  ? 3 :
                                 iNumMonster > 9   ? 2 : 1;
 
                // given the currently selected monster iActive. get the selected row
                int iSelPos = iActive;
                for( auto &ia : mSortCategory ) {
                    int index = ia.first;
                    if( index <= iSelPos ) {
                        ++iSelPos;
                    } else {
                        break;
                    }
                }
                int iStartPos = 0;
                // use selected row get the start row
                calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
 
                // get first visible monster and category
                int iCurMon = iStartPos;
                auto CatSortIter = mSortCategory.cbegin();
                while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
                    ++CatSortIter;
                    --iCurMon;
                }
 
                const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
                for( int y = 0; y < endY; ++y ) {
                    if( CatSortIter != mSortCategory.cend() ) {
                        const int iCurPos = iStartPos + y;
                        const int iCatPos = CatSortIter->first;
                        if( iCurPos == iCatPos ) {
                            const std::string cat_name = Creature::get_attitude_ui_data(
                                                             CatSortIter->second ).first.translated();
                            mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
                            ++CatSortIter;
                            continue;
                        }
                    }
                    // select current monster
                    const auto critter = monster_list[iCurMon];
                    const bool selected = iCurMon == iActive;
                    ++iCurMon;
                    if( critter->sees( g->u ) ) {
                        mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
                    }
                    bool is_npc = false;
                    const monster *m = dynamic_cast<monster *>( critter );
                    const npc     *p = dynamic_cast<npc *>( critter );
                    nc_color name_color = critter->basic_symbol_color();
 
                    if( selected ) {
                        name_color = hilite( name_color );
                    }
 
                    if( m != nullptr ) {
                        trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
                    } else {
                        trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
                        is_npc = true;
                    }
 
                    if( selected && !get_safemode().empty() ) {
                        const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
 
                        std::string sSafemode;
                        if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
                            sSafemode = _( "<R>emove from safemode Blacklist" );
                        } else {
                            sSafemode = _( "<A>dd to safemode Blacklist" );
                        }
 
                        shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
                                        c_white, c_light_green, sSafemode );
                    }
 
                    nc_color color = c_white;
                    std::string sText;
 
                    if( m != nullptr ) {
                        m->get_HP_Bar( color, sText );
                    } else {
                        std::tie( sText, color ) =
                            ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
                    }
                    mvwprintz( w_monsters, point( width - 25, y ), color, sText );
 
                    if( m != nullptr ) {
                        const auto att = m->get_attitude();
                        sText = att.first;
                        color = att.second;
                    } else if( p != nullptr ) {
                        sText = npc_attitude_name( p->get_attitude() );
                        color = p->symbol_color();
                    }
                    mvwprintz( w_monsters, point( width - 19, y ), color, sText );
 
                    const int mon_dist = rl_dist( u.pos(), critter->pos() );
                    const int numd = mon_dist > 999 ? 4 :
                                     mon_dist > 99 ? 3 :
                                     mon_dist > 9 ? 2 : 1;
 
                    trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
                                    selected ? c_light_green : c_light_gray,
                                    "%*d %s",
                                    numd, mon_dist,
                                    direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
                }
 
                mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
                           iActive + 1 );
                wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
 
                werase( w_monster_info );
                if( cCurMon ) {
                    cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
                }
 
                draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
                                    true );
 
                if( bVMonsterLookFire ) {
                    mvwprintw( w_monster_info_border, point_east, "< " );
                    wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
                    wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
 
                    if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
                        wprintw( w_monster_info_border, " " );
                        wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
                        wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
                    }
                    wprintw( w_monster_info_border, " >" );
                }
 
                draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
                                point_south );
            }
 
            wnoutrefresh( w_monsters_border );
            wnoutrefresh( w_monster_info_border );
            wnoutrefresh( w_monsters );
            wnoutrefresh( w_monster_info );
        }
    } );
 
    cata::optional<tripoint> trail_start;
    cata::optional<tripoint> trail_end;
    bool trail_end_x = false;
    shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
            trail_end_x );
    add_draw_callback( trail_cb );
 
    do {
        if( action == "UP" ) {
            iActive--;
            if( iActive < 0 ) {
                if( monster_list.empty() ) {
                    iActive = 0;
                } else {
                    iActive = static_cast<int>( monster_list.size() ) - 1;
                }
            }
        } else if( action == "DOWN" ) {
            iActive++;
            if( iActive >= static_cast<int>( monster_list.size() ) ) {
                iActive = 0;
            }
        } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
            u.view_offset = stored_view_offset;
            return game::vmenu_ret::CHANGE_TAB;
        } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
            const auto m = dynamic_cast<monster *>( cCurMon );
            const std::string monName = ( m != nullptr ) ? m->name() : "human";
 
            if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
                get_safemode().remove_rule( monName, Creature::A_ANY );
            }
        } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
            if( !get_safemode().empty() ) {
                const auto m = dynamic_cast<monster *>( cCurMon );
                const std::string monName = ( m != nullptr ) ? m->name() : "human";
 
                get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
                                         RULE_BLACKLISTED );
            }
        } else if( action == "look" ) {
            hide_ui = true;
            ui.mark_resize();
            look_around();
            hide_ui = false;
            ui.mark_resize();
        } else if( action == "fire" ) {
            if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
                u.last_target = shared_from( *cCurMon );
                u.recoil = MAX_RECOIL;
                u.view_offset = stored_view_offset;
                return game::vmenu_ret::FIRE;
            }
        }
 
        if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
            cCurMon = monster_list[iActive];
            iActivePos = cCurMon->pos() - u.pos();
            centerlistview( iActivePos, width );
            trail_start = u.pos();
            trail_end = cCurMon->pos();
            // Actually accessed from the terrain overlay callback `trail_cb` in the
            // call to `ui_manager::redraw`.
            //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            trail_end_x = false;
        } else {
            cCurMon = nullptr;
            iActivePos = tripoint_zero;
            u.view_offset = stored_view_offset;
            trail_start = trail_end = cata::nullopt;
        }
        invalidate_main_ui_adaptor();
 
        ui_manager::redraw();
 
        action = ctxt.handle_input();
    } while( action != "QUIT" );
 
    u.view_offset = stored_view_offset;
 
    return game::vmenu_ret::QUIT;
}

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

load() [1/2]

bool game::load ( const save_t &  name )

private

Definition at line 2841 of file game.cpp.

{
    background_pane background;
    static_popup popup;
    popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
    ui_manager::redraw();
    refresh_display();
 
    using namespace std::placeholders;
 
    const std::string worldpath = get_world_base_save_path() + "/";
    const std::string playerpath = worldpath + name.base_path();
 
    // Now load up the master game data; factions (and more?)
    load_master();
    u = avatar();
    u.name = name.player_name();
    // This should be initialized more globally (in player/Character constructor)
    u.weapon = item( "null", calendar::start_of_cataclysm );
    if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
        return false;
    }
 
    u.load_map_memory();
 
    get_weather().nextweather = calendar::turn;
 
    read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
                             std::bind( &memorial_logger::load, &memorial(), _1 ) );
 
#if defined(__ANDROID__)
    read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
                             std::bind( &game::load_shortcuts, this, _1 ) );
#endif
 
    // Now that the player's worn items are updated, their sight limits need to be
    // recalculated. (This would be cleaner if u.worn were private.)
    u.recalc_sight_limits();
 
    if( !gamemode ) {
        gamemode = std::make_unique<special_game>();
    }
 
    safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
    mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
 
    init_autosave();
    get_auto_pickup().load_character(); // Load character auto pickup rules
    get_auto_notes_settings().load();   // Load character auto notes settings
    get_safemode().load_character(); // Load character safemode rules
    zone_manager::get_manager().load_zones(); // Load character world zones
    read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
        JsonIn jsin( stream );
        uistate.deserialize( jsin );
    } );
    reload_npcs();
    validate_npc_followers();
    validate_mounted_npcs();
    validate_camps();
    validate_linked_vehicles();
    update_map( u );
    for( auto &e : u.inv_dump() ) {
        e->set_owner( g->u );
    }
    // legacy, needs to be here as we access the map.
    if( !u.getID().is_valid() ) {
        // player does not have a real id, so assign a new one,
        u.setID( assign_npc_id() );
        // The vehicle stores the IDs of the boarded players, so update it, too.
        if( u.in_vehicle ) {
            if( const cata::optional<vpart_reference> vp = m.veh_at(
                        u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
                vp->part().passenger_id = u.getID();
            }
        }
    }
 
    // populate calendar caches now, after active world is set, but before we do
    // anything else, to ensure they pick up the correct value from the save's
    // worldoptions
    calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
    calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
 
    u.reset();
 
    return true;
}

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

load() [2/2]

bool game::load

(

const std::string &

world

)

Attempt to load first valid save (if any) in world.

Definition at line 2817 of file game.cpp.

{
    world_generator->init();
    const WORLDPTR wptr = world_generator->get_world( world );
    if( !wptr ) {
        return false;
    }
    if( wptr->world_saves.empty() ) {
        debugmsg( "world '%s' contains no saves", world );
        return false;
    }
 
    try {
        world_generator->set_active_world( wptr );
        g->setup();
        g->load( wptr->world_saves.front() );
    } catch( const std::exception &err ) {
        debugmsg( "cannot load world '%s': %s", world, err.what() );
        return false;
    }
 
    return true;
}

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

load_core_data()

void game::load_core_data

(

loading_ui &

ui

)

Loads core dynamic data.

May throw.

Definition at line 435 of file game.cpp.

{
    // core data can be loaded only once and must be first
    // anyway.
    DynamicDataLoader::get_instance().unload_data();
 
    load_data_from_dir( PATH_INFO::jsondir(), "core", ui );
}

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path, const std::string &  src, loading_ui &  ui  )

protected

Loads dynamic data from the given directory.

May throw.

Definition at line 444 of file game.cpp.

{
    DynamicDataLoader::get_instance().load_data_from_path( path, src, ui );
}

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

load_map() [1/2]

void game::load_map

(

const tripoint &

pos_sm

)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 631 of file game.cpp.

{
    // TODO: fix point types
    load_map( tripoint_abs_sm( pos_sm ) );
}

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

load_map() [2/2]

void game::load_map

(

const tripoint_abs_sm &

pos_sm

)

Definition at line 637 of file game.cpp.

{
    m.load( pos_sm, true );
    grid_tracker_ptr->load( m );
}

References grid_tracker_ptr, map::load(), and m.

load_master()

void game::load_master ( )

private

Definition at line 2810 of file game.cpp.

{
    using namespace std::placeholders;
    const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
    read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
}

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

load_npcs()

void game::load_npcs

(

)

Makes any nearby NPCs on the overmap active.

Definition at line 895 of file game.cpp.

{
    const int radius = HALF_MAPSIZE - 1;
    // uses submap coordinates
    std::vector<shared_ptr_fast<npc>> just_added;
    for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
        const character_id &id = temp->getID();
        const auto found = std::find_if( active_npc.begin(), active_npc.end(),
        [id]( const shared_ptr_fast<npc> &n ) {
            return n->getID() == id;
        } );
        if( found != active_npc.end() ) {
            continue;
        }
        if( temp->is_active() ) {
            continue;
        }
        if( temp->has_companion_mission() ) {
            continue;
        }
 
        const tripoint sm_loc = temp->global_sm_location();
        // NPCs who are out of bounds before placement would be pushed into bounds
        // This can cause NPCs to teleport around, so we don't want that
        if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
            sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
            ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
            continue;
        }
 
        add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
                 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
        temp->place_on_map();
        if( !m.inbounds( temp->pos() ) ) {
            continue;
        }
        // In the rare case the npc was marked for death while
        // it was on the overmap. Kill it.
        if( temp->marked_for_death ) {
            temp->die( nullptr );
        } else {
            active_npc.push_back( temp );
            just_added.push_back( temp );
        }
    }
 
    for( const auto &npc : just_added ) {
        npc->on_load();
    }
 
    npcs_dirty = false;
}

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

load_packs()

bool game::load_packs	(	const std::string &	msg,
		const std::vector< mod_id > &	packs,
		loading_ui &	ui
	)

Load content packs.

Parameters

msg	string to display whilst loading prompt
packs	content packs to load in correct dependent order
ui	structure for load progress display

Returns

true if all packs were found, false if any were missing

Definition at line 2965 of file game.cpp.

{
    ui.new_context( msg );
    std::vector<mod_id> missing;
    std::vector<mod_id> available;
 
    for( const mod_id &e : packs ) {
        if( e.is_valid() ) {
            available.emplace_back( e );
            ui.add_entry( e->name() );
        } else {
            missing.push_back( e );
        }
    }
 
    ui.show();
    for( const auto &e : available ) {
        const MOD_INFORMATION &mod = *e;
        load_data_from_dir( mod.path, mod.ident.str(), ui );
        ui.proceed();
    }
 
    for( const auto &e : missing ) {
        debugmsg( "unknown content %s", e.c_str() );
    }
 
    return missing.empty();
}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

load_static_data()

void game::load_static_data

(

)

Loads static data that does not depend on mods or similar.

Definition at line 321 of file game.cpp.

{
    // UI stuff, not mod-specific per definition
    inp_mngr.init();            // Load input config JSON
    // Init mappings for loading the json stuff
    DynamicDataLoader::get_instance();
    fullscreen = false;
    was_fullscreen = false;
    show_panel_adm = false;
    panel_manager::get_manager().init();
 
    // These functions do not load stuff from json.
    // The content they load/initialize is hardcoded into the program.
    // Therefore they can be loaded here.
    // If this changes (if they load data from json), they have to
    // be moved to game::load_mod or game::load_core_data
 
    get_auto_pickup().load_global();
    get_safemode().load_global();
}

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

load_world_modfiles()

void game::load_world_modfiles

(

loading_ui &

ui

)

Loads core data and mods from the active world.

May throw.

Definition at line 2929 of file game.cpp.

{
    auto &mods = world_generator->active_world->active_mod_order;
 
    // remove any duplicates whilst preserving order (fixes #19385)
    std::set<mod_id> found;
    mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
        if( found.count( e ) ) {
            return true;
        } else {
            found.insert( e );
            return false;
        }
    } ), mods.end() );
 
    // require at least one core mod (saves before version 6 may implicitly require dda pack)
    if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
    return e->core;
} ) ) {
        mods.insert( mods.begin(), mod_id( "dda" ) );
    }
 
    load_artifacts( get_world_base_save_path() + "/" + SAVE_ARTIFACTS );
    // this code does not care about mod dependencies,
    // it assumes that those dependencies are static and
    // are resolved during the creation of the world.
    // That means world->active_mod_order contains a list
    // of mods in the correct order.
    load_packs( _( "Loading files" ), mods, ui );
 
    // Load additional mods from that world-specific folder
    load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
 
    DynamicDataLoader::get_instance().finalize_loaded_data( ui );
}

References world_generator.

Referenced by setup().

look_around() [1/2]

cata::optional< tripoint > game::look_around

(

)

Definition at line 6835 of file game.cpp.

{
    tripoint center = u.pos() + u.view_offset;
    look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
                                false );
    return result.position;
}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

look_around() [2/2]

look_around_result game::look_around	(	bool	show_window,
		tripoint &	center,
		const tripoint &	start_point,
		bool	has_first_point,
		bool	select_zone,
		bool	peeking,
		bool	is_moving_zone = false,
		const tripoint &	end_point = tripoint_zero
	)

Parameters

show_window	display the info window that holds the tile information in the position.
center	used to calculate the u.view_offset, could center the screen to the position it represents
start_point	the start point of the targeting zone, also the initial local position of the cursor
has_first_point	should be true if the first point has been selected when editing the zone
select_zone	true if the zone is being edited
peeking	determines if the player is peeking
is_moving_zone	true if the zone is being moved, false by default
end_point	the end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero

Returns

look_around_result

Definition at line 6843 of file game.cpp.

{
    bVMonsterLookFire = false;
    // TODO: Make this `true`
    const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
 
    temp_exit_fullscreen();
 
    tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
    int &lx = lp.x;
    int &ly = lp.y;
    int &lz = lp.z;
 
    int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
    bool fast_scroll = false;
 
    std::unique_ptr<ui_adaptor> ui;
    catacurses::window w_info;
    if( show_window ) {
        ui = std::make_unique<ui_adaptor>();
        ui->on_screen_resize( [&]( ui_adaptor & ui ) {
            int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
            int height = pixel_minimap_option ? TERMY - getmaxy( w_pixel_minimap ) : TERMY;
 
            // If particularly small, base height on panel width irrespective of other elements.
            // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
            if( height < panel_width / 2 ) {
                height = panel_width / 2;
            }
 
            int la_y = 0;
            int la_x = TERMX - panel_width;
            std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
            if( position == "left" ) {
                if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
                    la_x = panel_manager::get_manager().get_width_left();
                } else {
                    la_x = panel_manager::get_manager().get_width_left() - panel_width;
                }
            }
            int la_h = height;
            int la_w = panel_width;
            w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
 
            ui.position_from_window( w_info );
        } );
        ui->mark_resize();
    }
 
    std::string action;
    input_context ctxt( "LOOK" );
    ctxt.set_iso( true );
    ctxt.register_directions();
    ctxt.register_action( "COORDINATE" );
    ctxt.register_action( "LEVEL_UP" );
    ctxt.register_action( "LEVEL_DOWN" );
    ctxt.register_action( "TOGGLE_FAST_SCROLL" );
    ctxt.register_action( "EXTENDED_DESCRIPTION" );
    ctxt.register_action( "SELECT" );
    if( peeking ) {
        ctxt.register_action( "throw_blind" );
    }
    if( !select_zone ) {
        ctxt.register_action( "TRAVEL_TO" );
        ctxt.register_action( "LIST_ITEMS" );
    }
    ctxt.register_action( "MOUSE_MOVE" );
    ctxt.register_action( "CENTER" );
 
    ctxt.register_action( "debug_scent" );
    ctxt.register_action( "debug_scent_type" );
    ctxt.register_action( "debug_temp" );
    ctxt.register_action( "debug_visibility" );
    ctxt.register_action( "debug_lighting" );
    ctxt.register_action( "debug_radiation" );
    ctxt.register_action( "debug_submap_grid" );
    ctxt.register_action( "debug_hour_timer" );
    ctxt.register_action( "CONFIRM" );
    ctxt.register_action( "QUIT" );
    ctxt.register_action( "HELP_KEYBINDINGS" );
    if( use_tiles ) {
        ctxt.register_action( "zoom_out" );
        ctxt.register_action( "zoom_in" );
    }
#if defined(TILES)
    ctxt.register_action( "toggle_pixel_minimap" );
#endif // TILES
 
    const int old_levz = get_levz();
    const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
    const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
 
    m.update_visibility_cache( old_levz );
    const visibility_variables &cache = g->m.get_visibility_variables_cache();
 
    bool blink = true;
    look_around_result result;
 
    shared_ptr_fast<draw_callback_t> ter_indicator_cb;
 
    if( show_window && ui ) {
        ui->on_redraw( [&]( const ui_adaptor & ) {
            werase( w_info );
            draw_border( w_info );
 
            center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
 
            std::string extended_descr_text = string_format( _( "%s - %s" ),
                                              ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
                                              ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
            std::string fast_scroll_text = string_format( _( "%s - %s" ),
                                           ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
                                           ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
#if defined(TILES)
            std::string pixel_minimap_text = string_format( _( "%s - %s" ),
                                             ctxt.get_desc( "toggle_pixel_minimap" ),
                                             ctxt.get_action_name( "toggle_pixel_minimap" ) );
#endif // TILES
 
            center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
            mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
                       fast_scroll_text );
#if defined(TILES)
            right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
                         pixel_minimap_text );
#endif // TILES
 
            int first_line = 1;
            const int last_line = getmaxy( w_info ) - 3;
            pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
 
            wnoutrefresh( w_info );
        } );
        ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
            draw_look_around_cursor( lp, cache );
        } );
        add_draw_callback( ter_indicator_cb );
    }
 
    cata::optional<tripoint> zone_start;
    cata::optional<tripoint> zone_end;
    bool zone_blink = false;
    bool zone_cursor = true;
    shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
            zone_cursor, is_moving_zone );
    add_draw_callback( zone_cb );
 
    is_looking = true;
    const tripoint prev_offset = u.view_offset;
#if defined(TILES)
    const int prev_tileset_zoom = tileset_zoom;
    while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
           get_zoom() != 4 ) {
        zoom_out();
    }
    mark_main_ui_adaptor_resize();
#endif
    do {
        u.view_offset = center - u.pos();
        if( select_zone ) {
            if( has_first_point ) {
                zone_start = start_point;
                zone_end = lp;
            } else {
                zone_start = lp;
                zone_end = cata::nullopt;
            }
            // Actually accessed from the terrain overlay callback `zone_cb` in the
            // call to `ui_manager::redraw`.
            //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            zone_blink = blink;
        }
 
        if( is_moving_zone ) {
            zone_start = lp - ( start_point + end_point ) / 2 + start_point;
            zone_end = lp - ( start_point + end_point ) / 2 + end_point;
            // Actually accessed from the terrain overlay callback `zone_cb` in the
            // call to `ui_manager::redraw`.
            //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            zone_blink = blink;
        }
        invalidate_main_ui_adaptor();
        ui_manager::redraw();
        if( ( select_zone && has_first_point ) || is_moving_zone ) {
            ctxt.set_timeout( BLINK_SPEED );
        }
 
        //Wait for input
        // only specify a timeout here if "EDGE_SCROLL" is enabled
        // otherwise use the previously set timeout
        const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
        const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
        const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
        if( edge_scrolling ) {
            action = ctxt.handle_input( scroll_timeout );
        } else {
            action = ctxt.handle_input();
        }
        if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
              ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
            blink = true; // Always draw blink symbols when moving cursor
        } else if( action == "TIMEOUT" ) {
            blink = !blink;
        }
        if( action == "LIST_ITEMS" ) {
            list_items_monsters();
        } else if( action == "TOGGLE_FAST_SCROLL" ) {
            fast_scroll = !fast_scroll;
        } else if( action == "toggle_pixel_minimap" ) {
            toggle_pixel_minimap();
 
            if( show_window && ui ) {
                ui->mark_resize();
            }
        } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
            if( !allow_zlev_move ) {
                continue;
            }
 
            const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
            lz = clamp( lz + dz, min_levz, max_levz );
            center.z = clamp( center.z + dz, min_levz, max_levz );
 
            add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
            u.view_offset.z = center.z - u.posz();
            m.invalidate_map_cache( center.z );
        } else if( action == "TRAVEL_TO" ) {
            if( !u.sees( lp ) ) {
                add_msg( _( "You can't see that destination." ) );
                continue;
            }
 
            auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
            if( route.size() > 1 ) {
                route.pop_back();
                u.set_destination( route );
            } else {
                add_msg( m_info, _( "You can't travel there." ) );
                continue;
            }
        } else if( action == "debug_scent" || action == "debug_scent_type" ) {
            if( !MAP_SHARING::isCompetitive() || MAP_SHARING::isDebugger() ) {
                display_scent();
            }
        } else if( action == "debug_temp" ) {
            if( !MAP_SHARING::isCompetitive() || MAP_SHARING::isDebugger() ) {
                display_temperature();
            }
        } else if( action == "debug_lighting" ) {
            if( !MAP_SHARING::isCompetitive() || MAP_SHARING::isDebugger() ) {
                display_lighting();
            }
        } else if( action == "debug_transparency" ) {
            if( !MAP_SHARING::isCompetitive() || MAP_SHARING::isDebugger() ) {
                display_transparency();
            }
        } else if( action == "debug_radiation" ) {
            if( !MAP_SHARING::isCompetitive() || MAP_SHARING::isDebugger() ) {
                display_radiation();
            }
        } else if( action == "debug_submap_grid" ) {
            g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
        } else if( action == "debug_hour_timer" ) {
            toggle_debug_hour_timer();
        } else if( action == "EXTENDED_DESCRIPTION" ) {
            extended_description( lp );
        } else if( action == "CENTER" ) {
            center = u.pos();
            lp = u.pos();
            u.view_offset.z = 0;
        } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
            // This block is structured this way so that edge scroll can work
            // whether the mouse is moving at the edge or simply stationary
            // at the edge. But even if edge scroll isn't in play, there's
            // other things for us to do here.
 
            if( edge_scrolling ) {
                center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
            } else if( action == "MOUSE_MOVE" ) {
                const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
                if( mouse_pos ) {
                    lx = mouse_pos->x;
                    ly = mouse_pos->y;
                }
            }
        } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
            if( fast_scroll ) {
                vec->x *= soffset;
                vec->y *= soffset;
            }
 
            lx = lx + vec->x;
            ly = ly + vec->y;
            center.x = center.x + vec->x;
            center.y = center.y + vec->y;
        } else if( action == "throw_blind" ) {
            result.peek_action = PA_BLIND_THROW;
        } else if( action == "zoom_in" ) {
            center.x = lp.x;
            center.y = lp.y;
            zoom_in();
            mark_main_ui_adaptor_resize();
        } else if( action == "zoom_out" ) {
            center.x = lp.x;
            center.y = lp.y;
            zoom_out();
            mark_main_ui_adaptor_resize();
        }
    } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
             action != "throw_blind" );
 
    if( m.has_zlevels() && center.z != old_levz ) {
        m.invalidate_map_cache( old_levz );
        m.build_map_cache( old_levz );
        u.view_offset.z = 0;
    }
 
    ctxt.reset_timeout();
    u.view_offset = prev_offset;
    zone_cb = nullptr;
    is_looking = false;
 
    reenter_fullscreen();
    bVMonsterLookFire = true;
 
    if( action == "CONFIRM" || action == "SELECT" ) {
        result.position = is_moving_zone ? zone_start : lp;
    }
 
#if defined(TILES)
    if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
        // Reset the tileset zoom to the previous value
        set_zoom( prev_tileset_zoom );
        mark_main_ui_adaptor_resize();
    }
#endif
 
    return result;
}

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

look_debug()

cata::optional< tripoint > game::look_debug

(

)

Definition at line 5941 of file game.cpp.

{
    editmap edit;
    return edit.edit();
}

References editmap::edit().

mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize

(

)

const

Definition at line 3343 of file game.cpp.

{
    shared_ptr_fast<ui_adaptor> ui = main_ui_adaptor.lock();
    if( ui ) {
        ui->mark_resize();
    }
}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

memorial()

memorial_logger & game::memorial

(

)

Definition at line 3085 of file game.cpp.

{
    return *memorial_logger_ptr;
}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

mon_info()

void game::mon_info	(	const catacurses::window &	w,
		int	hor_padding = 0
	)

Definition at line 4034 of file game.cpp.

{
    const monster_visible_info &mon_visible = u.get_mon_visible();
    const auto &unique_types = mon_visible.unique_types;
    const auto &unique_mons = mon_visible.unique_mons;
    const auto &dangerous = mon_visible.dangerous;
 
    const int width = getmaxx( w ) - 2 * hor_padding;
    const int maxheight = getmaxy( w );
 
    const int startrow = 0;
 
    // Print the direction headings
    // Reminder:
    // 7 0 1    unique_types uses these indices;
    // 6 8 2    0-7 are provide by direction_from()
    // 5 4 3    8 is used for local monsters (for when we explain them below)
 
    const std::array<std::string, 8> dir_labels = {{
            _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
            _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
        }
    };
    std::array<int, 8> widths;
    for( int i = 0; i < 8; i++ ) {
        widths[i] = utf8_width( dir_labels[i] );
    }
    std::array<int, 8> xcoords;
    const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
    xcoords[0] = xcoords[4] = width / 3;
    xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
    xcoords[5] = xcoords[6] = xcoords[7] = 0;
    //for the alignment of the 1,2,3 rows on the right edge
    xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
    for( int i = 0; i < 8; i++ ) {
        nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
                     : ( dangerous[i] ? c_light_red : c_light_gray );
        mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
    }
 
    // Print the symbols of all monsters in all directions.
    for( int i = 0; i < 8; i++ ) {
        point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
 
        // The list of symbols needs a space on each end.
        int symroom = ( width / 3 ) - widths[i] - 2;
        const int typeshere_npc = unique_types[i].size();
        const int typeshere_mon = unique_mons[i].size();
        const int typeshere = typeshere_mon + typeshere_npc;
        for( int j = 0; j < typeshere && j < symroom; j++ ) {
            nc_color c;
            std::string sym;
            if( symroom < typeshere && j == symroom - 1 ) {
                // We've run out of room!
                c = c_white;
                sym = "+";
            } else if( j < typeshere_npc ) {
                switch( unique_types[i][j]->get_attitude() ) {
                    case NPCATT_KILL:
                        c = c_red;
                        break;
                    case NPCATT_FOLLOW:
                        c = c_light_green;
                        break;
                    default:
                        c = c_pink;
                        break;
                }
                sym = "@";
            } else {
                const mtype &mt = *unique_mons[i][j - typeshere_npc];
                c = mt.color;
                sym = mt.sym;
            }
            mvwprintz( w, pr, c, sym );
 
            pr.x++;
        }
    }
 
    // Now we print their full names!
 
    std::set<const mtype *> listed_mons;
 
    // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
    // is blank.
    point pr( hor_padding, 4 + startrow );
 
    // Print monster names, starting with those at location 8 (nearby).
    for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
        // Separate names by some number of spaces (more for local monsters).
        int namesep = ( j == 8 ? 2 : 1 );
        for( const mtype *type : unique_mons[j] ) {
            if( pr.y >= maxheight ) {
                // no space to print to anyway
                break;
            }
            if( listed_mons.count( type ) > 0 ) {
                // this type is already printed.
                continue;
            }
            listed_mons.insert( type );
 
            const mtype &mt = *type;
            const std::string name = mt.nname();
 
            // Move to the next row if necessary. (The +2 is for the "Z ").
            if( pr.x + 2 + utf8_width( name ) >= width ) {
                pr.y++;
                pr.x = hor_padding;
            }
 
            if( pr.y < maxheight ) { // Don't print if we've overflowed
                mvwprintz( w, pr, mt.color, mt.sym );
                pr.x += 2; // symbol and space
                nc_color danger = c_dark_gray;
                if( mt.difficulty >= 30 ) {
                    danger = c_red;
                } else if( mt.difficulty >= 16 ) {
                    danger = c_light_red;
                } else if( mt.difficulty >= 8 ) {
                    danger = c_white;
                } else if( mt.agro > 0 ) {
                    danger = c_light_gray;
                }
                mvwprintz( w, pr, danger, name );
                pr.x += utf8_width( name ) + namesep;
            }
        }
    }
}

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

mon_info_update()

void game::mon_info_update

(

)

Definition at line 4166 of file game.cpp.

{
    int newseen = 0;
    const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
    const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
                           safe_proxy_dist;
 
    monster_visible_info &mon_visible = u.get_mon_visible();
    auto &new_seen_mon = mon_visible.new_seen_mon;
    auto &unique_types = mon_visible.unique_types;
    auto &unique_mons = mon_visible.unique_mons;
    auto &dangerous = mon_visible.dangerous;
 
    // 7 0 1    unique_types uses these indices;
    // 6 8 2    0-7 are provide by direction_from()
    // 5 4 3    8 is used for local monsters (for when we explain them below)
    for( auto &t : unique_types ) {
        t.clear();
    }
    for( auto &m : unique_mons ) {
        m.clear();
    }
    std::fill( dangerous, dangerous + 8, false );
 
    const tripoint view = u.pos() + u.view_offset;
    new_seen_mon.clear();
 
    // TODO: no reason to have it static here
    static time_point previous_turn = calendar::start_of_cataclysm;
    const time_duration sm_ignored_time = time_duration::from_turns(
            get_option<int>( "SAFEMODEIGNORETURNS" ) );
 
    for( Creature *c : u.get_visible_creatures( MAPSIZE_X ) ) {
        monster *m = dynamic_cast<monster *>( c );
        npc *p = dynamic_cast<npc *>( c );
        const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
        const int mx = POSX + ( c->posx() - view.x );
        const int my = POSY + ( c->posy() - view.y );
        int index = 8;
        if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
            // for compatibility with old code, see diagram below, it explains the values for index,
            // also might need revisiting one z-levels are in.
            switch( dir_to_mon ) {
                case direction::ABOVENORTHWEST:
                case direction::NORTHWEST:
                case direction::BELOWNORTHWEST:
                    index = 7;
                    break;
                case direction::ABOVENORTH:
                case direction::NORTH:
                case direction::BELOWNORTH:
                    index = 0;
                    break;
                case direction::ABOVENORTHEAST:
                case direction::NORTHEAST:
                case direction::BELOWNORTHEAST:
                    index = 1;
                    break;
                case direction::ABOVEWEST:
                case direction::WEST:
                case direction::BELOWWEST:
                    index = 6;
                    break;
                case direction::ABOVECENTER:
                case direction::CENTER:
                case direction::BELOWCENTER:
                    index = 8;
                    break;
                case direction::ABOVEEAST:
                case direction::EAST:
                case direction::BELOWEAST:
                    index = 2;
                    break;
                case direction::ABOVESOUTHWEST:
                case direction::SOUTHWEST:
                case direction::BELOWSOUTHWEST:
                    index = 5;
                    break;
                case direction::ABOVESOUTH:
                case direction::SOUTH:
                case direction::BELOWSOUTH:
                    index = 4;
                    break;
                case direction::ABOVESOUTHEAST:
                case direction::SOUTHEAST:
                case direction::BELOWSOUTHEAST:
                    index = 3;
                    break;
            }
        }
 
        rule_state safemode_state = RULE_NONE;
        const bool safemode_empty = get_safemode().empty();
 
        if( m != nullptr ) {
            //Safemode monster check
            monster &critter = *m;
 
            const monster_attitude matt = critter.attitude( &u );
            const int mon_dist = rl_dist( u.pos(), critter.pos() );
            safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
 
            if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
                    ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
                if( index < 8 && critter.sees( g->u ) ) {
                    dangerous[index] = true;
                }
 
                if( !safemode_empty || mon_dist <= iProxyDist ) {
                    bool passmon = false;
                    if( critter.ignoring > 0 ) {
                        if( safe_mode != SAFE_MODE_ON ) {
                            critter.ignoring = 0;
                        } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
                                     *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
                                   ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
                            passmon = true;
                        }
                        critter.lastseen_turn = calendar::turn;
                    }
 
                    if( !passmon ) {
                        newseen++;
                        new_seen_mon.push_back( shared_from( critter ) );
                    }
                }
            }
 
            std::vector<const mtype *> &vec = unique_mons[index];
            if( std::find( vec.begin(), vec.end(), critter.type ) == vec.end() ) {
                vec.push_back( critter.type );
            }
        } else if( p != nullptr ) {
            //Safe mode NPC check
 
            const int npc_dist = rl_dist( u.pos(), p->pos() );
            safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
                             npc_dist );
 
            if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
                    p->get_attitude() == NPCATT_KILL ) ) {
                if( !safemode_empty || npc_dist <= iProxyDist ) {
                    newseen++;
                }
            }
            unique_types[index].push_back( p );
        }
    }
 
    if( newseen > mostseen ) {
        if( newseen - mostseen == 1 ) {
            if( !new_seen_mon.empty() ) {
                monster &critter = *new_seen_mon.back();
                cancel_activity_or_ignore_query( distraction_type::hostile_spotted_far,
                                                 string_format( _( "%s spotted!" ), critter.name() ) );
                if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
                    add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
                    if( !u.has_effect( effect_adrenaline_mycus ) ) {
                        u.add_effect( effect_adrenaline_mycus, 30_minutes );
                    } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
                        // Triffids present.  We ain't got TIME to adrenaline comedown!
                        u.add_effect( effect_adrenaline_mycus, 15_minutes );
                        u.mod_pain( 3 ); // Does take it out of you, though
                        add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
                    }
                }
            } else {
                //Hostile NPC
                cancel_activity_or_ignore_query( distraction_type::hostile_spotted_far,
                                                 _( "Hostile survivor spotted!" ) );
            }
        } else {
            cancel_activity_or_ignore_query( distraction_type::hostile_spotted_far, _( "Monsters spotted!" ) );
        }
        turnssincelastmon = 0;
        if( safe_mode == SAFE_MODE_ON ) {
            set_safe_mode( SAFE_MODE_STOP );
        }
    } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
               newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
        turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
        if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
            set_safe_mode( SAFE_MODE_ON );
            add_msg( m_info, _( "Safe mode ON!" ) );
        }
    }
 
    if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
        set_safe_mode( SAFE_MODE_ON );
    }
 
    previous_turn = calendar::turn;
    mostseen = newseen;
}

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), detail::find(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

monmove()

void game::monmove ( )

private

Definition at line 4396 of file game.cpp.

{
    cleanup_dead();
 
    for( monster &critter : all_monsters() ) {
        // Critters in impassable tiles get pushed away, unless it's not impassable for them
        if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
            std::string msg = string_format( "%s can't move to its location!  %s  %s", critter.name(),
                                             critter.pos().to_string(), m.tername( critter.pos() ) );
            dbg( DL::Error ) << msg;
            add_msg( m_debug, msg );
            bool okay = false;
            for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
                if( critter.can_move_to( dest ) && is_empty( dest ) ) {
                    critter.setpos( dest );
                    okay = true;
                    break;
                }
            }
            if( !okay ) {
                // die of "natural" cause (overpopulation is natural)
                critter.die( nullptr );
            }
        }
 
        if( !critter.is_dead() ) {
            critter.process_items();
        }
 
        if( !critter.is_dead() ) {
            critter.process_turn();
        }
 
        m.creature_in_field( critter );
        if( calendar::once_every( 1_days ) ) {
            if( critter.has_flag( MF_MILKABLE ) ) {
                critter.refill_udders();
            }
            critter.try_reproduce();
        }
        while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
            critter.made_footstep = false;
            // Controlled critters don't make their own plans
            if( !critter.has_effect( effect_ai_controlled ) ) {
                // Formulate a path to follow
                critter.plan();
            }
            critter.move(); // Move one square, possibly hit u
            critter.process_triggers();
            m.creature_in_field( critter );
        }
 
        if( !critter.is_dead() &&
            u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
            u.get_power_level() >= 25_kJ &&
            rl_dist( u.pos(), critter.pos() ) <= 5 &&
            !critter.is_hallucination() ) {
            u.mod_power_level( -25_kJ );
            add_msg( m_warning, _( "Your motion alarm goes off!" ) );
            cancel_activity_or_ignore_query( distraction_type::motion_alarm,
                                             _( "Your motion alarm goes off!" ) );
            if( u.has_effect( efftype_id( "sleep" ) ) ) {
                u.wake_up();
            }
        }
    }
 
    cleanup_dead();
 
    // The remaining monsters are all alive, but may be outside of the reality bubble.
    // If so, despawn them. This is not the same as dying, they will be stored for later and the
    // monster::die function is not called.
    for( monster &critter : all_monsters() ) {
        if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
            critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
            critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
            critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
            despawn_monster( critter );
        }
    }
 
    // Now, do active NPCs.
    for( npc &guy : g->all_npcs() ) {
        int turns = 0;
        if( guy.is_mounted() ) {
            guy.check_mount_is_spooked();
        }
        m.creature_in_field( guy );
        if( !guy.has_effect( effect_npc_suspend ) ) {
            guy.process_turn();
        }
        while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
               ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
             ) {
            int moves = guy.moves;
            guy.move();
            if( moves == guy.moves ) {
                // Count every time we exit npc::move() without spending any moves.
                turns++;
            }
 
            // Turn on debug mode when in infinite loop
            // It has to be done before the last turn, otherwise
            // there will be no meaningful debug output.
            if( turns == 9 ) {
                debugmsg( "NPC %s entered infinite loop.  Turning on debug mode",
                          guy.name );
                debug_mode = true;
            }
        }
 
        // If we spun too long trying to decide what to do (without spending moves),
        // Invoke cognitive suspension to prevent an infinite loop.
        if( turns == 10 ) {
            add_msg( _( "%s faints!" ), guy.name );
            guy.reboot();
        }
 
        if( !guy.is_dead() ) {
            guy.npc_update_body();
        }
    }
    cleanup_dead();
}

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context &  ctxt, int  speed, const tripoint &  last, bool  iso  )

private

Definition at line 2339 of file game.cpp.

{
    const int rate = get_option<int>( "EDGE_SCROLL" );
    auto ret = std::make_pair( tripoint_zero, last );
    if( rate == -1 ) {
        // Fast return when the option is disabled.
        return ret;
    }
    // Ensure the parameters are used even if the #if below is false
    ( void ) ctxt;
    ( void ) speed;
    ( void ) iso;
#if (defined TILES || defined _WIN32 || defined WINDOWS)
    auto now = std::chrono::steady_clock::now();
    if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
        return ret;
    } else {
        last_mouse_edge_scroll = now;
    }
    const input_event event = ctxt.get_raw_input();
    if( event.type == CATA_INPUT_MOUSE ) {
        const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
        if( event.mouse_pos.x <= threshold.x ) {
            ret.first.x -= speed;
            if( iso ) {
                ret.first.y -= speed;
            }
        } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
            ret.first.x += speed;
            if( iso ) {
                ret.first.y += speed;
            }
        }
        if( event.mouse_pos.y <= threshold.y ) {
            ret.first.y -= speed;
            if( iso ) {
                ret.first.x += speed;
            }
        } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
            ret.first.y += speed;
            if( iso ) {
                ret.first.x -= speed;
            }
        }
        ret.second = ret.first;
    } else if( event.type == CATA_INPUT_TIMEOUT ) {
        ret.first = ret.second;
    }
#endif
    return ret;
}

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap

(

input_context &

ctxt

)

This variant is suitable for the overmap.

Definition at line 2401 of file game.cpp.

{
    // overmap has no iso mode
    auto ret = mouse_edge_scrolling( ctxt, 2, last_mouse_edge_scroll_vector_overmap, false );
    last_mouse_edge_scroll_vector_overmap = ret.second;
    last_mouse_edge_scroll_vector_terrain = tripoint_zero;
    return ret.first;
}

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain

(

input_context &

ctxt

)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2392 of file game.cpp.

{
    auto ret = mouse_edge_scrolling( ctxt, std::max( DEFAULT_TILESET_ZOOM / tileset_zoom, 1 ),
                                     last_mouse_edge_scroll_vector_terrain, tile_iso );
    last_mouse_edge_scroll_vector_terrain = ret.second;
    last_mouse_edge_scroll_vector_overmap = tripoint_zero;
    return ret.first;
}

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname )

private

Definition at line 2772 of file game.cpp.

{
    const std::string save_dir           = get_world_base_save_path();
    const std::string graveyard_dir      = PATH_INFO::graveyarddir() + "/";
    const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
    const std::string prefix             = base64_encode( u.name ) + ".";
 
    if( !assure_dir_exist( graveyard_dir ) ) {
        debugmsg( "could not create graveyard path '%s'", graveyard_dir );
    }
 
    if( !assure_dir_exist( graveyard_save_dir ) ) {
        debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
    }
 
    const auto save_files = get_files_from_path( prefix, save_dir );
    if( save_files.empty() ) {
        debugmsg( "could not find save files in '%s'", save_dir );
    }
 
    for( const auto &src_path : save_files ) {
        const std::string dst_path = graveyard_save_dir +
                                     src_path.substr( src_path.rfind( '/' ), std::string::npos );
 
        if( rename_file( src_path, dst_path ) ) {
            continue;
        }
 
        debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
 
        if( remove_file( src_path ) ) {
            continue;
        }
 
        debugmsg( "could not remove file '%s'", src_path );
    }
}

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

moving_vehicle_dismount()

void game::moving_vehicle_dismount

(

const tripoint &

dest_loc

)

Handles players exiting from moving vehicles.

Definition at line 5410 of file game.cpp.

{
    const optional_vpart_position vp = m.veh_at( u.pos() );
    if( !vp ) {
        debugmsg( "Tried to exit non-existent vehicle." );
        return;
    }
    vehicle *const veh = &vp->vehicle();
    if( u.pos() == dest_loc ) {
        debugmsg( "Need somewhere to dismount towards." );
        return;
    }
    tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
    // TODO:: make dir() const correct!
    const units::angle d = ray.dir();
    add_msg( _( "You dive from the %s." ), veh->name );
    m.unboard_vehicle( u.pos() );
    u.moves -= 200;
    // Dive three tiles in the direction of tox and toy
    fling_creature( &u, d, 30, true );
    // Hit the ground according to vehicle speed
    if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
        if( veh->velocity > 0 ) {
            fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
        } else {
            fling_creature( &u, veh->face.dir() + 180_degrees,
                            -( veh->velocity ) / static_cast<float>( 100 ) );
        }
    }
}

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

natural_light_level()

float game::natural_light_level

(

int

zlev

)

const

Definition at line 3853 of file game.cpp.

{
    // ignore while underground or above limits
    if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
        return LIGHT_AMBIENT_MINIMAL;
    }
 
    if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
        // Already found the light level for now?
        return latest_lightlevels[zlev];
    }
 
    float ret = LIGHT_AMBIENT_MINIMAL;
 
    // Sunlight/moonlight related stuff
    const weather_manager &weather = get_weather();
    if( !weather.lightning_active ) {
        ret = sunlight( calendar::turn );
    } else {
        // Recent lightning strike has lit the area
        ret = default_daylight_level();
    }
 
    ret += get_weather().weather_id->light_modifier;
 
    // Artifact light level changes here. Even though some of these only have an effect
    // aboveground it is cheaper performance wise to simply iterate through the entire
    // list once instead of twice.
    float mod_ret = -1;
    // Each artifact change does std::max(mod_ret, new val) since a brighter end value
    // will trump a lower one.
    if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
        // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
        const time_duration left = e->when - calendar::turn;
        // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
        if( left > 25_turns ) {
            mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
            // and the last 25 scale back towards normal.
        } else {
            mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
        }
    }
    if( timed_events.queued( TIMED_EVENT_ARTIFACT_LIGHT ) ) {
        // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
        mod_ret = std::max<float>( ret, default_daylight_level() );
    }
    // If we had a changed light level due to an artifact event then it overwrites
    // the natural light level.
    if( mod_ret > -1 ) {
        ret = mod_ret;
    }
 
    // Cap everything to our minimum light level
    ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
 
    latest_lightlevels[zlev] = ret;
 
    return ret;
}

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

npc_menu()

bool game::npc_menu

(

npc &

who

)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5541 of file game.cpp.

{
    enum choices : int {
        talk = 0,
        swap_pos,
        push,
        examine_wounds,
        use_item,
        sort_armor,
        attack,
        disarm,
        steal
    };
 
    const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
 
    uilist amenu;
 
    amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
    amenu.addentry( talk, true, 't', _( "Talk" ) );
    amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
                    !u.is_mounted(), 's', _( "Swap positions" ) );
    amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
    amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
    amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
    amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
    amenu.addentry( attack, true, 'a', _( "Attack" ) );
    if( !who.is_player_ally() ) {
        amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
        amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
    }
 
    amenu.query();
 
    const int choice = amenu.ret;
    if( choice == talk ) {
        who.talk_to_u();
    } else if( choice == swap_pos ) {
        if( !prompt_dangerous_tile( who.pos() ) ) {
            return true;
        }
        // TODO: Make NPCs protest when displaced onto dangerous crap
        add_msg( _( "You swap places with %s." ), who.name );
        swap_critters( u, who );
        // TODO: Make that depend on stuff
        u.mod_moves( -200 );
    } else if( choice == push ) {
        // TODO: Make NPCs protest when displaced onto dangerous crap
        tripoint oldpos = who.pos();
        who.move_away_from( u.pos(), true );
        u.mod_moves( -20 );
        if( oldpos != who.pos() ) {
            add_msg( _( "%s moves out of the way." ), who.name );
        } else {
            add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
        }
    } else if( choice == examine_wounds ) {
        ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
 
        ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
        const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
        who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
                         0.0f, 0.0f );
    } else if( choice == use_item ) {
        static const std::string heal_string( "heal" );
        const auto will_accept = []( const item & it ) {
            const auto use_fun = it.get_use( heal_string );
            if( use_fun == nullptr ) {
                return false;
            }
 
            const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
 
            return actor != nullptr &&
                   actor->limb_power >= 0 &&
                   actor->head_power >= 0 &&
                   actor->torso_power >= 0;
        };
        item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
 
        if( !loc ) {
            add_msg( _( "Never mind" ) );
            return false;
        }
        item &used = *loc;
        bool did_use = u.invoke_item( &used, heal_string, who.pos() );
        if( did_use ) {
            // Note: exiting a body part selection menu counts as use here
            u.mod_moves( -300 );
        }
    } else if( choice == sort_armor ) {
        who.sort_armor();
        u.mod_moves( -100 );
    } else if( choice == attack ) {
        if( who.is_enemy() || query_yn( _( "You may be attacked!  Proceed?" ) ) ) {
            u.melee_attack( who, true );
            who.on_attacked( u );
        }
    } else if( choice == disarm ) {
        if( who.is_enemy() || query_yn( _( "You may be attacked!  Proceed?" ) ) ) {
            u.disarm( who );
        }
    } else if( choice == steal && query_yn( _( "You may be attacked!  Proceed?" ) ) ) {
        u.steal( who );
    }
 
    return true;
}

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

num_creatures()

size_t game::num_creatures

(

)

const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 5012 of file game.cpp.

{
    return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

on_move_effects()

void game::on_move_effects

(

)

Definition at line 10263 of file game.cpp.

{
    // TODO: Move this to a character method
    if( !u.is_mounted() ) {
        const item muscle( "muscle" );
        for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
            if( u.has_active_bionic( bid ) ) {// active power gen
                u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
            } else if( u.has_bionic( bid ) ) {// passive power gen
                u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
            }
        }
 
        if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
            if( u.movement_mode_is( CMM_RUN ) ) {
                u.mod_power_level( -55_J );
            } else {
                u.mod_power_level( -35_J );
            }
        }
    }
 
    if( u.movement_mode_is( CMM_RUN ) ) {
        if( !u.can_run() ) {
            u.toggle_run_mode();
        }
    }
 
    // apply martial art move bonuses
    u.martial_arts_data->ma_onmove_effects( u );
 
    sfx::do_ambient();
}

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

on_options_changed()

void game::on_options_changed

(

)

Should be invoked whenever options change.

Definition at line 10297 of file game.cpp.

{
#if defined(TILES)
    tilecontext->on_options_changed();
#endif
    grid_tracker_ptr->on_options_changed();
}

References grid_tracker_ptr.

open_consume_item_menu()

void game::open_consume_item_menu ( )

private

Definition at line 1490 of file handle_action.cpp.

{
    uilist as_m;
 
    as_m.text = _( "What do you want to consume?" );
 
    as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
    as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
    as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
    as_m.query();
 
    switch( as_m.ret ) {
        case 0:
            avatar_action::eat( u, game_menus::inv::consume_food( u ) );
            break;
        case 1:
            avatar_action::eat( u, game_menus::inv::consume_drink( u ) );
            break;
        case 2:
            avatar_action::eat( u, game_menus::inv::consume_meds( u ) );
            break;
        default:
            break;
    }
}

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

open_gate()

void game::open_gate

(

const tripoint &

p

)

Definition at line 5405 of file game.cpp.

{
    gates::open_gate( p, u );
}

References gates::open_gate(), and u.

overmap_npc_move()

void game::overmap_npc_move ( )

private

Definition at line 4521 of file game.cpp.

{
    std::vector<npc *> travelling_npcs;
    static constexpr int move_search_radius = 600;
    for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
        if( !elem ) {
            continue;
        }
        npc *npc_to_add = elem.get();
        if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
            npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
            travelling_npcs.push_back( npc_to_add );
        }
    }
    for( auto &elem : travelling_npcs ) {
        if( elem->has_omt_destination() ) {
            if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
                //recalculate path, we got distracted doing something else probably
                elem->omt_path.clear();
            }
            if( elem->omt_path.empty() ) {
                const tripoint_abs_omt &from = elem->global_omt_location();
                const tripoint_abs_omt &to = elem->goal;
                elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
                                 overmap_path_params::for_npc() );
                if( elem->omt_path.empty() ) {
                    add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
                             elem->get_name(), from.to_string(), to.to_string() );
                    elem->goal = npc::no_goal_point;
                    elem->mission = NPC_MISSION_NULL;
                }
            } else {
                if( elem->omt_path.back() == elem->global_omt_location() ) {
                    elem->omt_path.pop_back();
                }
                // TODO: fix point types
                elem->travel_overmap(
                    project_to<coords::sm>( elem->omt_path.back() ).raw() );
            }
            reload_npcs();
        }
    }
    return;
}

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

peek() [1/2]

void game::peek

(

)

Definition at line 5899 of file game.cpp.

{
    const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
    if( !p ) {
        return;
    }
 
    if( p->z != 0 ) {
        const tripoint old_pos = u.pos();
        vertical_move( p->z, false, true );
 
        if( old_pos != u.pos() ) {
            look_around();
            vertical_move( p->z * -1, false, true );
        }
        return;
    }
 
    if( m.impassable( u.pos() + *p ) ) {
        return;
    }
 
    peek( u.pos() + *p );
}

References _, choose_direction(), map::impassable(), look_around(), m, peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

peek() [2/2]

void game::peek

(

const tripoint &

p

)

Definition at line 5924 of file game.cpp.

{
    u.moves -= 200;
    tripoint prev = u.pos();
    u.setpos( p );
    tripoint center = p;
    const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
                                      true );
    u.setpos( prev );
 
    if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
        item_location loc;
        avatar_action::plthrow( u, loc, p );
    }
    m.invalidate_map_cache( p.z );
}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )

private

Definition at line 11570 of file game.cpp.

{
    if( !calendar::once_every( 1_hours ) ) {
        return;
    }
    // Create a new NPC?
    // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
    if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
        return;
    }
 
    float density = get_option<float>( "NPC_DENSITY" );
    static constexpr int density_search_radius = 60;
    const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
    if( npc_num > 0.0 ) {
        // 100%, 80%, 64%, 52%, 41%, 33%...
        density *= std::pow( 0.8f, npc_num );
    }
 
    if( !x_in_y( density, 100 ) ) {
        return;
    }
    bool spawn_allowed = false;
    tripoint_abs_omt spawn_point;
    int counter = 0;
    while( !spawn_allowed ) {
        if( counter >= 10 ) {
            return;
        }
        static constexpr int radius_spawn_range = 120;
        const tripoint_abs_omt u_omt = u.global_omt_location();
        spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
                                     rng( -radius_spawn_range, radius_spawn_range ) );
        spawn_point.z() = 0;
        const oter_id oter = overmap_buffer.ter( spawn_point );
        // shouldn't spawn on lakes or rivers.
        if( !is_river_or_lake( oter ) ) {
            spawn_allowed = true;
        }
        counter += 1;
    }
    shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
    tmp->normalize();
    tmp->randomize();
    std::string new_fac_id = "solo_";
    new_fac_id += tmp->name;
    // create a new "lone wolf" faction for this one NPC
    faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
                            faction_id( "no_faction" ) );
    tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
    // adds the npc to the correct overmap.
    // Only spawn random NPCs on z-level 0
    // TODO: fix point types
    tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
    tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
    overmap_buffer.insert_npc( tmp );
    tmp->form_opinion( u );
    tmp->mission = NPC_MISSION_NULL;
    tmp->long_term_goal_action();
    tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
                          tmp->getID() ) );
    // This will make the new NPC active- if its nearby to the player
    load_npcs();
}

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

phasing_move()

bool game::phasing_move	(	const tripoint &	dest,
		bool	via_ramp = false
	)

Definition at line 9995 of file game.cpp.

{
    if( dest_loc.z != u.posz() && !via_ramp ) {
        // No vertical phasing yet
        return false;
    }
 
    //probability travel through walls but not water
    tripoint dest = dest_loc;
    // tile is impassable
    int tunneldist = 0;
    const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
    while( m.impassable( dest ) ||
           ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
        //add 1 to tunnel distance for each impassable tile in the line
        tunneldist += 1;
        //Being dimensionally anchored prevents quantum shenanigans.
        if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
            u.add_msg_if_player( m_info,
                                 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
            return false;
        }
 
        if( tunneldist > 24 ) {
            add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
            return false;
        }
 
        dest.x += d.x;
        dest.y += d.y;
    }
 
    if( tunneldist != 0 ) {
        if( ( tunneldist - 1 ) * 100_kJ
            > //The first 100 was already taken up by the bionic's activation cost.
            u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
            if( tunneldist * 100_kJ >
                u.get_max_power_level() ) {
                add_msg( _( "You try to quantum tunnel through the barrier but bounce off!  You don't have enough bionic power capacity to travel that far." ) );
            } else {
                add_msg( _( "You try to quantum tunnel through the barrier but are reflected!  You need %i bionic power to travel that thickness of material." ),
                         ( 100 * tunneldist ) );
            }
            return false;
        }
 
        if( u.in_vehicle ) {
            m.unboard_vehicle( u.pos() );
        }
 
        add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
        //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
        u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
        //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
        u.moves -= ( 50 + ( tunneldist * 50 ) );
        u.setpos( dest );
 
        if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
            m.board_vehicle( u.pos(), &u );
        }
 
        u.grab( OBJECT_NONE );
        on_move_effects();
        m.creature_on_trap( u );
        return true;
    }
 
    return false;
}

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

pickup() [1/2]

void game::pickup ( )

private

Definition at line 5870 of file game.cpp.

{
    const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
                                            _( "There is nothing to pick up nearby." ),
                                            ACTION_PICKUP, false );
    if( !examp_ ) {
        return;
    }
    pickup( *examp_ );
}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

pickup() [2/2]

void game::pickup ( const tripoint &  p )

private

Definition at line 5881 of file game.cpp.

{
    // Highlight target
    shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
        m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
    } );
    add_draw_callback( hilite_cb );
 
    pickup::pick_up( p, 0 );
}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

pickup_feet()

void game::pickup_feet ( )

private

Definition at line 5892 of file game.cpp.

{
    pickup::pick_up( u.pos(), 1 );
}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

place_critter_around() [1/2]

monster * game::place_critter_around	(	const mtype_id &	id,
		const tripoint &	center,
		int	radius
	)

Definition at line 4960 of file game.cpp.

{
    // TODO: change this into an assert, it must never happen.
    if( id.is_null() ) {
        return nullptr;
    }
    return place_critter_around( make_shared_fast<monster>( id ), center, radius );
}

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

place_critter_around() [2/2]

monster * game::place_critter_around	(	const shared_ptr_fast< monster > &	mon,
		const tripoint &	center,
		int	radius,
		bool	forced = false
	)

Definition at line 4969 of file game.cpp.

{
    cata::optional<tripoint> where;
    if( forced || can_place_monster( *mon, center ) ) {
        where = center;
    }
 
    // This loop ensures the monster is placed as close to the center as possible,
    // but all places that equally far from the center have the same probability.
    for( int r = 1; r <= radius && !where; ++r ) {
        where = choose_where_to_place_monster( *mon, m.points_in_radius( center, r ) );
    }
 
    if( !where ) {
        return nullptr;
    }
    mon->spawn( *where );
    return critter_tracker->add( mon ) ? mon.get() : nullptr;
}

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

place_critter_at() [1/2]

monster * game::place_critter_at	(	const mtype_id &	id,
		const tripoint &	p
	)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns

All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4950 of file game.cpp.

{
    return place_critter_around( id, p, 0 );
}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

place_critter_at() [2/2]

monster * game::place_critter_at	(	const shared_ptr_fast< monster > &	mon,
		const tripoint &	p
	)

Definition at line 4955 of file game.cpp.

{
    return place_critter_around( mon, p, 0 );
}

References place_critter_around().

place_critter_within() [1/2]

monster * game::place_critter_within	(	const mtype_id &	id,
		const tripoint_range< tripoint > &	range
	)

Definition at line 4992 of file game.cpp.

{
    // TODO: change this into an assert, it must never happen.
    if( id.is_null() ) {
        return nullptr;
    }
    return place_critter_within( make_shared_fast<monster>( id ), range );
}

References place_critter_within().

Referenced by place_critter_within().

place_critter_within() [2/2]

monster * game::place_critter_within	(	const shared_ptr_fast< monster > &	mon,
		const tripoint_range< tripoint > &	range
	)

Definition at line 5001 of file game.cpp.

{
    const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
    if( !where ) {
        return nullptr;
    }
    mon->spawn( *where );
    return critter_tracker->add( mon ) ? mon.get() : nullptr;
}

References choose_where_to_place_monster(), and critter_tracker.

place_player()

point game::place_player

(

const tripoint &

dest

)

Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9634 of file game.cpp.

{
    const optional_vpart_position vp1 = m.veh_at( dest_loc );
    if( const cata::optional<std::string> label = vp1.get_label() ) {
        add_msg( m_info, _( "Label here: %s" ), *label );
    }
    std::string signage = m.get_signage( dest_loc );
    if( !signage.empty() ) {
        if( !u.has_trait( trait_ILLITERATE ) ) {
            add_msg( m_info, _( "The sign says: %s" ), signage );
        } else {
            add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
        }
    }
    if( m.has_graffiti_at( dest_loc ) ) {
        if( !u.has_trait( trait_ILLITERATE ) ) {
            add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
        } else {
            add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
        }
    }
    // TODO: Move the stuff below to a Character method so that NPCs can reuse it
    if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
        if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
            add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
                     m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
                         dest_loc ) );
            u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
        }
        if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
            add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
                     m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
                         dest_loc ) );
            u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
        }
    }
    ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
    if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
        ( !u.in_vehicle && !g->m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
                one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
        if( u.is_mounted() ) {
            add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
            u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
        } else {
            const bodypart_id bp = u.get_random_body_part();
            if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
                //~ 1$s - bodypart name in accusative, 2$s is terrain name.
                add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
                         body_part_name_accusative( bp->token ),
                         m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
                             dest_loc ) );
            }
        }
    }
    if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
        u.add_effect( effect_bouldering, 1_turns, num_bp );
    } else if( u.has_effect( effect_bouldering ) ) {
        u.remove_effect( effect_bouldering );
    }
    if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
        u.add_effect( effect_no_sight, 1_turns, num_bp );
    } else if( u.has_effect( effect_no_sight ) ) {
        u.remove_effect( effect_no_sight );
    }
 
    // If we moved out of the nonant, we need update our map data
    if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
        add_msg( _( "The water puts out the flames!" ) );
        u.remove_effect( effect_onfire );
        if( u.is_mounted() ) {
            monster *mon = u.mounted_creature.get();
            if( mon->has_effect( effect_onfire ) ) {
                mon->remove_effect( effect_onfire );
            }
        }
    }
 
    if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
        // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
        // Immobile monsters can't be displaced.
        monster &critter = *mon_ptr;
        // TODO: handling for ridden creatures other than players mount.
        if( !critter.has_effect( effect_ridden ) ) {
            if( u.is_mounted() ) {
                std::vector<tripoint> valid;
                for( const tripoint &jk : g->m.points_in_radius( critter.pos(), 1 ) ) {
                    if( is_empty( jk ) ) {
                        valid.push_back( jk );
                    }
                }
                if( !valid.empty() ) {
                    critter.move_to( random_entry( valid ) );
                    add_msg( _( "You push the %s out of the way." ), critter.name() );
                } else {
                    add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
                    return u.pos().xy();
                }
            } else {
                critter.move_to( u.pos(), false,
                                 true ); // Force the movement even though the player is there right now.
                add_msg( _( "You displace the %s." ), critter.name() );
            }
        } else if( !u.has_effect( effect_riding ) ) {
            add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
            return u.pos().xy();
        }
    }
 
    // If the player is in a vehicle, unboard them from the current part
    if( u.in_vehicle ) {
        m.unboard_vehicle( u.pos() );
    }
    // Move the player
    // Start with z-level, to make it less likely that old functions (2D ones) freak out
    if( m.has_zlevels() && dest_loc.z != get_levz() ) {
        vertical_shift( dest_loc.z );
    }
 
    if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
                            m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
                            vp1 ) ) {
        u.stop_hauling();
    }
    u.setpos( dest_loc );
    if( u.is_mounted() ) {
        monster *mon = u.mounted_creature.get();
        mon->setpos( dest_loc );
        mon->process_triggers();
        m.creature_in_field( *mon );
    }
    point submap_shift = update_map( u );
    // Important: don't use dest_loc after this line. `update_map` may have shifted the map
    // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
    // If you must use it you can calculate the position in the new, shifted system with
    // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
 
    //Auto pulp or butcher and Auto foraging
    if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0  && !u.is_mounted() ) {
        static const direction adjacentDir[8] = { direction::NORTH, direction::NORTHEAST, direction::EAST, direction::SOUTHEAST, direction::SOUTH, direction::SOUTHWEST, direction::WEST, direction::NORTHWEST };
 
        const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
        if( forage_type != "off" ) {
            const auto forage = [&]( const tripoint & pos ) {
                const auto &xter_t = m.ter( pos ).obj().examine;
                const auto &xfurn_t = m.furn( pos ).obj().examine;
                const bool forage_everything = forage_type == "both";
                const bool forage_bushes = forage_everything || forage_type == "bushes";
                const bool forage_trees = forage_everything || forage_type == "trees";
                if( xter_t == &iexamine::none ) {
                    return;
                } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
                           ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
                           ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
                           ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
                           ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
                           ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
                         ) {
                    xter_t( u, pos );
                } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
                           ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
                         ) {
                    xfurn_t( u, pos );
                }
            };
 
            for( auto &elem : adjacentDir ) {
                forage( u.pos() + direction_XY( elem ) );
            }
        }
 
        const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
        if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
            std::vector<item *> corpses;
 
            for( item &it : m.i_at( u.pos() ) ) {
                corpses.push_back( &it );
            }
 
            if( !corpses.empty() ) {
                u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
                for( item *it : corpses ) {
                    u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
                }
            }
        } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
            const auto pulp = [&]( const tripoint & pos ) {
                for( const auto &maybe_corpse : m.i_at( pos ) ) {
                    if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
                        !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
                        u.assign_activity( activity_id( "ACT_PULP" ), calendar::INDEFINITELY_LONG, 0 );
                        u.activity.placement = g->m.getabs( pos );
                        u.activity.auto_resume = true;
                        u.activity.str_values.push_back( "auto_pulp_no_acid" );
                        return;
                    }
                }
            };
 
            if( pulp_butcher == "pulp_adjacent" ) {
                for( auto &elem : adjacentDir ) {
                    pulp( u.pos() + direction_XY( elem ) );
                }
            } else {
                pulp( u.pos() );
            }
        }
    }
 
    //Autopickup
    if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
        ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
        ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
        pickup::pick_up( u.pos(), -1 );
    }
 
    // If the new tile is a boardable part, board it
    if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
        m.board_vehicle( u.pos(), &u );
    }
 
    // Traps!
    // Try to detect.
    u.search_surroundings();
    if( u.is_mounted() ) {
        m.creature_on_trap( *u.mounted_creature );
    } else {
        m.creature_on_trap( u );
    }
    // Drench the player if swimmable
    if( m.has_flag( "SWIMMABLE", u.pos() ) &&
        !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
        u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
    }
 
    // List items here
    if( !m.has_flag( "SEALED", u.pos() ) ) {
        if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
            !g->check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
            if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
                add_msg( _( "There's something here, but you can't see what it is." ) );
            } else if( m.has_items( u.pos() ) ) {
                std::vector<std::string> names;
                std::vector<size_t> counts;
                std::vector<item> items;
                for( auto &tmpitem : m.i_at( u.pos() ) ) {
 
                    std::string next_tname = tmpitem.tname();
                    std::string next_dname = tmpitem.display_name();
                    bool by_charges = tmpitem.count_by_charges();
                    bool got_it = false;
                    for( size_t i = 0; i < names.size(); ++i ) {
                        if( by_charges && next_tname == names[i] ) {
                            counts[i] += tmpitem.charges;
                            got_it = true;
                            break;
                        } else if( next_dname == names[i] ) {
                            counts[i] += 1;
                            got_it = true;
                            break;
                        }
                    }
                    if( !got_it ) {
                        if( by_charges ) {
                            names.push_back( tmpitem.tname( tmpitem.charges ) );
                            counts.push_back( tmpitem.charges );
                        } else {
                            names.push_back( tmpitem.display_name( 1 ) );
                            counts.push_back( 1 );
                        }
                        items.push_back( tmpitem );
                    }
                    if( names.size() > 10 ) {
                        break;
                    }
                }
                for( size_t i = 0; i < names.size(); ++i ) {
                    if( !items[i].count_by_charges() ) {
                        names[i] = items[i].display_name( counts[i] );
                    } else {
                        names[i] = items[i].tname( counts[i] );
                    }
                }
                int and_the_rest = 0;
                for( size_t i = 0; i < names.size(); ++i ) {
                    //~ number of items: "<number> <item>"
                    std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
                    names[i] = string_format( fmt, counts[i], names[i] );
                    // Skip the first two.
                    if( i > 1 ) {
                        and_the_rest += counts[i];
                    }
                }
                if( names.size() == 1 ) {
                    add_msg( _( "You see here %s." ), names[0] );
                } else if( names.size() == 2 ) {
                    add_msg( _( "You see here %s and %s." ), names[0], names[1] );
                } else if( names.size() == 3 ) {
                    add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
                } else if( and_the_rest < 7 ) {
                    add_msg( vgettext( "You see here %s, %s and %d more item.",
                                       "You see here %s, %s and %d more items.",
                                       and_the_rest ),
                             names[0], names[1], and_the_rest );
                } else {
                    add_msg( _( "You see here %s and many more items." ), names[0] );
                }
            }
        }
    }
 
    if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
          vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
        add_msg( _( "There are vehicle controls here." ) );
        if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
            add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
        }
    } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
               u.is_mounted() ) {
        add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
    }
    return submap_shift;
}

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), g, Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

place_player_overmap()

void game::place_player_overmap

(

const tripoint_abs_omt &

om_dest

)

Definition at line 9957 of file game.cpp.

{
    // if player is teleporting around, they don't bring their horse with them
    if( u.is_mounted() ) {
        u.remove_effect( effect_riding );
        u.mounted_creature->remove_effect( effect_ridden );
        u.mounted_creature = nullptr;
    }
    // offload the active npcs.
    unload_npcs();
    for( monster &critter : all_monsters() ) {
        despawn_monster( critter );
    }
    if( u.in_vehicle ) {
        m.unboard_vehicle( u.pos() );
    }
    const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
    const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
    for( int z = minz; z <= maxz; z++ ) {
        m.clear_vehicle_cache( z );
        m.clear_vehicle_list( z );
    }
    m.access_cache( get_levz() ).map_memory_seen_cache.reset();
    // offset because load_map expects the coordinates of the top left corner, but the
    // player will be centered in the middle of the map.
    // TODO: fix point types
    const tripoint map_sm_pos(
        project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
    const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
    load_map( map_sm_pos );
    load_npcs();
    m.spawn_monsters( true ); // Static monsters
    update_overmap_seen();
    // update weather now as it could be different on the new location
    get_weather().nextweather = calendar::turn;
    place_player( player_pos );
}

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id &  id, const point_abs_omt &  origin, int  min_distance, int  max_distance, const std::vector< std::string > &  omt_search_types = {}  )

private

Definition at line 844 of file game.cpp.

{
    std::vector<std::string> search_types = omt_search_types;
    if( search_types.empty() ) {
        vehicle veh( id );
        if( veh.can_float() ) {
            search_types.push_back( "river" );
            search_types.push_back( "lake" );
        } else {
            search_types.push_back( "field" );
            search_types.push_back( "road" );
        }
    }
    for( const std::string &search_type : search_types ) {
        omt_find_params find_params;
        find_params.must_see = false;
        find_params.cant_see = false;
        find_params.types.emplace_back( search_type, ot_match_type::type );
        // find nearest road
        find_params.min_distance = min_distance;
        find_params.search_range = max_distance;
        // if player spawns underground, park their car on the surface.
        const tripoint_abs_omt omt_origin( origin, 0 );
        for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
            // try place vehicle there.
            tinymap target_map;
            target_map.load( project_to<coords::sm>( goal ), false );
            const tripoint tinymap_center( SEEX, SEEY, goal.z() );
            static constexpr std::array<units::angle, 4> angles = {{
                    0_degrees, 90_degrees, 180_degrees, 270_degrees
                }
            };
            vehicle *veh = target_map.add_vehicle(
                               id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
            if( veh ) {
                tripoint abs_local = g->m.getlocal( target_map.getabs( tinymap_center ) );
                veh->sm_pos =  ms_to_sm_remain( abs_local );
                veh->pos = abs_local.xy();
                overmap_buffer.add_vehicle( veh );
                veh->tracking_on = true;
                target_map.save();
                return veh;
            }
        }
    }
    return nullptr;
}

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), g, map::getabs(), map::load(), omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

pre_print_all_tile_info()

void game::pre_print_all_tile_info	(	const tripoint &	lp,
		const catacurses::window &	w_info,
		int &	line,
		int	last_line,
		const visibility_variables &	cache
	)

Definition at line 6822 of file game.cpp.

{
    // get global area info according to look_around caret position
    // TODO: fix point types
    const oter_id &cur_ter_m = overmap_buffer.ter( tripoint_abs_omt( ms_to_omt_copy( m.getabs(
                                   lp ) ) ) );
    // we only need the area name and then pass it to print_all_tile_info() function below
    const std::string area_name = cur_ter_m->get_name();
    print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
}

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

print_all_tile_info()

void game::print_all_tile_info	(	const tripoint &	lp,
		const catacurses::window &	w_look,
		const std::string &	area_name,
		int	column,
		int &	line,
		int	last_line,
		const visibility_variables &	cache
	)

Definition at line 6002 of file game.cpp.

{
    visibility_type visibility = VIS_HIDDEN;
    const bool inbounds = m.inbounds( lp );
    if( inbounds ) {
        visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
    }
    const Creature *creature = critter_at( lp, true );
    switch( visibility ) {
        case VIS_CLEAR: {
            const optional_vpart_position vp = m.veh_at( lp );
            print_terrain_info( lp, w_look, area_name, column, line );
            print_fields_info( lp, w_look, column, line );
            print_trap_info( lp, w_look, column, line );
            print_creature_info( creature, w_look, column, line, last_line );
            print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
                                last_line );
            print_items_info( lp, w_look, column, line, last_line );
            print_graffiti_info( lp, w_look, column, line, last_line );
        }
        break;
        case VIS_BOOMER:
        case VIS_BOOMER_DARK:
        case VIS_DARK:
        case VIS_LIT:
        case VIS_HIDDEN:
            print_visibility_info( w_look, column, line, visibility );
 
            if( creature != nullptr ) {
                std::vector<std::string> buf;
                if( u.sees_with_infrared( *creature ) ) {
                    creature->describe_infrared( buf );
                } else if( u.sees_with_specials( *creature ) ) {
                    creature->describe_specials( buf );
                }
                for( const std::string &s : buf ) {
                    mvwprintw( w_look, point( 1, ++line ), s );
                }
            }
            break;
    }
    if( !inbounds ) {
        return;
    }
    auto this_sound = sounds::sound_at( lp );
    if( !this_sound.empty() ) {
        mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
    } else {
        // Check other z-levels
        tripoint tmp = lp;
        for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
            if( tmp.z == lp.z ) {
                continue;
            }
 
            auto zlev_sound = sounds::sound_at( tmp );
            if( !zlev_sound.empty() ) {
                mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
                           _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
            }
        }
    }
}

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

print_creature_info()

void game::print_creature_info ( const Creature *  creature, const catacurses::window &  w_look, int  column, int &  line, int  last_line  )

private

Definition at line 6209 of file game.cpp.

{
    int vLines = last_line - line;
    if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
        line = creature->print_info( w_look, ++line, vLines, column );
    }
}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

print_fields_info()

void game::print_fields_info ( const tripoint &  lp, const catacurses::window &  w_look, int  column, int &  line  )

private

Definition at line 6172 of file game.cpp.

{
    const field &tmpfield = m.field_at( lp );
    for( auto &fld : tmpfield ) {
        const field_entry &cur = fld.second;
        if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
                                          m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
            const int max_width = getmaxx( w_look ) - column - 2;
            int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
                                        get_fire_fuel_string( lp ) ) - 1;
            line += lines;
        } else {
            mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
        }
    }
}

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

print_graffiti_info()

void game::print_graffiti_info ( const tripoint &  lp, const catacurses::window &  w_look, int  column, int &  line, int  last_line  )

private

Definition at line 6264 of file game.cpp.

{
    if( line > last_line ) {
        return;
    }
 
    const int max_width = getmaxx( w_look ) - column - 2;
    if( m.has_graffiti_at( lp ) ) {
        fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
                        m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
                        m.graffiti_at( lp ) );
    }
}

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

print_items_info()

void game::print_items_info ( const tripoint &  lp, const catacurses::window &  w_look, int  column, int &  line, int  last_line  )

private

Definition at line 6227 of file game.cpp.

{
    if( !m.sees_some_items( lp, u ) ) {
        return;
    } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
        mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
    } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
        mvwprintz( w_look, point( column, ++line ), c_yellow,
                   _( "There's something there, but you can't see what it is." ) );
        return;
    } else {
        std::map<std::string, int> item_names;
        for( auto &item : m.i_at( lp ) ) {
            ++item_names[item.tname()];
        }
 
        const int max_width = getmaxx( w_look ) - column - 1;
        for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
            // last line but not last item
            if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
                mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
                break;
            }
 
            if( it->second > 1 ) {
                trim_and_print( w_look, point( column, ++line ), max_width, c_white,
                                pgettext( "%s is the name of the item.  %d is the quantity of that item.", "%s [%d]" ),
                                it->first.c_str(), it->second );
            } else {
                trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
            }
        }
    }
}

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

print_terrain_info()

void game::print_terrain_info ( const tripoint &  lp, const catacurses::window &  w_look, const std::string &  area_name, int  column, int &  line  )

private

Definition at line 6099 of file game.cpp.

{
    const int max_width = getmaxx( w_look ) - column - 1;
    int lines;
 
    const auto fmt_tile_info = []( const tripoint & lp ) {
        map &here = get_map();
        std::string ret;
        if( debug_mode ) {
            ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
            if( here.has_furn( lp ) ) {
                ret += "; " + here.furn( lp )->id.str();
            }
        } else {
            ret = here.tername( lp );
            if( here.has_furn( lp ) ) {
                ret += "; " + here.furnname( lp );
            }
        }
        return ret;
    };
 
    std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
 
    if( m.impassable( lp ) ) {
        lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
                                _( "%s; Impassable" ),
                                tile );
    } else {
        lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
                                _( "%s; Movement cost %d" ),
                                tile, m.move_cost( lp ) * 50 );
 
        const auto ll = get_light_level( std::max( 1.0,
                                         LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
        mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
        wprintz( w_look, ll.second, ll.first );
    }
 
    std::string signage = m.get_signage( lp );
    if( !signage.empty() ) {
        trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
                        // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
                        u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
    }
 
    if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
        // Print info about stuff below
        tripoint below( lp.xy(), lp.z - 1 );
        std::string tile_below = fmt_tile_info( below );
 
        if( !m.has_floor_or_support( lp ) ) {
            fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
                            _( "Below: %s; No support" ),
                            tile_below );
        } else {
            fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
                            _( "Below: %s; Walkable" ),
                            tile_below );
        }
    }
 
    int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
                                       m.features( lp ) );
    fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
                    m.coverage( lp ) );
    if( line < lines ) {
        line = lines + map_features - 1;
    }
}

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

print_trap_info()

void game::print_trap_info ( const tripoint &  lp, const catacurses::window &  w_look, int  column, int &  line  )

private

Definition at line 6190 of file game.cpp.

{
    const trap &tr = m.tr_at( lp );
    if( tr.can_see( lp, u ) ) {
        partial_con *pc = g->m.partial_con_at( lp );
        std::string tr_name;
        if( pc && tr.loadid == tr_unfinished_construction ) {
            const construction &built = pc->id.obj();
            tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.description,
                                     pc->counter / 100000 );
        } else {
            tr_name = tr.name();
        }
 
        mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
    }
}

References _, trap::can_see(), trap::color, partial_con::counter, construction::description, g, partial_con::id, line(), trap::loadid, m, mvwprintz(), trap::name(), int_id< T >::obj(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

print_vehicle_info()

void game::print_vehicle_info ( const vehicle *  veh, int  veh_part, const catacurses::window &  w_look, int  column, int &  line, int  last_line  )

private

Definition at line 6218 of file game.cpp.

{
    if( veh ) {
        mvwprintw( w_look, point( column, ++line ), _( "There is a %s there.  Parts:" ), veh->name );
        line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
    }
}

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

print_visibility_info()

void game::print_visibility_info ( const catacurses::window &  w_look, int  column, int &  line, visibility_type  visibility  )

private

Definition at line 6070 of file game.cpp.

{
    const char *visibility_message = nullptr;
    switch( visibility ) {
        case VIS_CLEAR:
            visibility_message = _( "Clearly visible." );
            break;
        case VIS_BOOMER:
            visibility_message = _( "A bright pink blur." );
            break;
        case VIS_BOOMER_DARK:
            visibility_message = _( "A pink blur." );
            break;
        case VIS_DARK:
            visibility_message = _( "Darkness." );
            break;
        case VIS_LIT:
            visibility_message = _( "Bright light." );
            break;
        case VIS_HIDDEN:
            visibility_message = _( "Unseen." );
            break;
    }
 
    mvwprintw( w_look, point( line, column ), visibility_message );
    line += 2;
}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

process_activity()

void game::process_activity ( )

private

Definition at line 1739 of file game.cpp.

{
    if( !u.activity ) {
        return;
    }
 
    while( u.moves > 0 && u.activity ) {
        u.activity.do_turn( u );
    }
}

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

process_artifact()

void game::process_artifact	(	item &	it,
		player &	p
	)

Definition at line 11844 of file game.cpp.

{
    const bool worn = p.is_worn( it );
    const bool wielded = ( &it == &p.weapon );
    std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
    if( worn ) {
        const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
        effects.insert( effects.end(), ew.begin(), ew.end() );
    }
    if( wielded ) {
        const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
        effects.insert( effects.end(), ew.begin(), ew.end() );
    }
 
    if( it.is_tool() ) {
        // Recharge it if necessary
        if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
            //Before incrementing charge, check that any extra requirements are met
            if( check_art_charge_req( it ) ) {
                switch( it.type->artifact->charge_type ) {
                    case ARTC_NULL:
                    case NUM_ARTCS:
                        break; // dummy entries
                    case ARTC_TIME:
                        // Once per hour
                        if( calendar::once_every( 1_hours ) ) {
                            it.charges++;
                        }
                        break;
                    case ARTC_SOLAR:
                        if( calendar::once_every( 10_minutes ) &&
                            is_in_sunlight( p.pos() ) ) {
                            it.charges++;
                        }
                        break;
                    // Artifacts can inflict pain even on Deadened folks.
                    // Some weird Lovecraftian thing.  ;P
                    // (So DON'T route them through mod_pain!)
                    case ARTC_PAIN:
                        if( calendar::once_every( 1_minutes ) ) {
                            add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
                            p.mod_pain_noresist( 3 * rng( 1, 3 ) );
                            it.charges++;
                        }
                        break;
                    case ARTC_HP:
                        if( calendar::once_every( 1_minutes ) ) {
                            add_msg( m_bad, _( "You feel your body decaying." ) );
                            p.hurtall( 1, nullptr );
                            it.charges++;
                        }
                        break;
                    case ARTC_FATIGUE:
                        if( calendar::once_every( 1_minutes ) ) {
                            add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
                            u.mod_fatigue( 3 * rng( 1, 3 ) );
                            u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
                            it.charges++;
                        }
                        break;
                    // Portals are energetic enough to charge the item.
                    // Tears in reality are consumed too, but can't charge it.
                    case ARTC_PORTAL:
                        for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
                            m.remove_field( dest, fd_fatigue );
                            if( m.tr_at( dest ).loadid == tr_portal ) {
                                add_msg( m_good, _( "The portal collapses!" ) );
                                m.remove_trap( dest );
                                it.charges++;
                                break;
                            }
                        }
                        break;
                }
            }
        }
    }
 
    for( const art_effect_passive &i : effects ) {
        switch( i ) {
            case AEP_STR_UP:
                p.mod_str_bonus( +4 );
                break;
            case AEP_DEX_UP:
                p.mod_dex_bonus( +4 );
                break;
            case AEP_PER_UP:
                p.mod_per_bonus( +4 );
                break;
            case AEP_INT_UP:
                p.mod_int_bonus( +4 );
                break;
            case AEP_ALL_UP:
                p.mod_str_bonus( +2 );
                p.mod_dex_bonus( +2 );
                p.mod_per_bonus( +2 );
                p.mod_int_bonus( +2 );
                break;
            case AEP_SPEED_UP:
                // Handled in player::current_speed()
                break;
 
            case AEP_PBLUE:
                if( p.get_rad() > 0 ) {
                    p.mod_rad( -1 );
                }
                break;
 
            case AEP_SMOKE:
                if( one_in( 10 ) ) {
                    tripoint pt( p.posx() + rng( -1, 1 ),
                                 p.posy() + rng( -1, 1 ),
                                 p.posz() );
                    m.add_field( pt, fd_smoke, rng( 1, 3 ) );
                }
                break;
 
            case AEP_SNAKES:
                break; // Handled in player::hit()
 
            case AEP_EXTINGUISH:
                for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
                    m.mod_field_age( dest, fd_fire, -1_turns );
                }
                break;
 
            case AEP_FUN:
                //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
                p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
                break;
 
            case AEP_HUNGER:
                if( one_in( 100 ) ) {
                    p.mod_stored_kcal( -10 );
                }
                break;
 
            case AEP_THIRST:
                if( one_in( 120 ) ) {
                    p.mod_thirst( 1 );
                }
                break;
 
            case AEP_EVIL:
                if( one_in( 150 ) ) { // Once every 15 minutes, on average
                    p.add_effect( effect_evil, 30_minutes );
                    if( it.is_armor() ) {
                        if( !worn ) {
                            add_msg( _( "You have an urge to wear the %s." ),
                                     it.tname() );
                        }
                    } else if( !wielded ) {
                        add_msg( _( "You have an urge to wield the %s." ),
                                 it.tname() );
                    }
                }
                break;
 
            case AEP_SCHIZO:
                break; // Handled in player::suffer()
 
            case AEP_RADIOACTIVE:
                if( one_in( 4 ) ) {
                    p.irradiate( 1.0f );
                }
                break;
 
            case AEP_STR_DOWN:
                p.mod_str_bonus( -3 );
                break;
 
            case AEP_DEX_DOWN:
                p.mod_dex_bonus( -3 );
                break;
 
            case AEP_PER_DOWN:
                p.mod_per_bonus( -3 );
                break;
 
            case AEP_INT_DOWN:
                p.mod_int_bonus( -3 );
                break;
 
            case AEP_ALL_DOWN:
                p.mod_str_bonus( -2 );
                p.mod_dex_bonus( -2 );
                p.mod_per_bonus( -2 );
                p.mod_int_bonus( -2 );
                break;
 
            case AEP_SPEED_DOWN:
                break; // Handled in player::current_speed()
 
            default:
                //Suppress warnings
                break;
        }
    }
    // Recalculate, as it might have changed (by mod_*_bonus above)
    p.str_cur = p.get_str();
    p.int_cur = p.get_int();
    p.dex_cur = p.get_dex();
    p.per_cur = p.get_per();
}

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )

private

Definition at line 1700 of file game.cpp.

{
    if( u.has_effect( effect_sleep ) ) {
        // Can't interrupt
        return;
    }
 
    bool has_activity = u.activity && u.activity.moves_left > 0;
    bool is_travelling = u.has_destination() && !u.omt_path.empty();
 
    if( !has_activity && !is_travelling ) {
        // Nohing to interrupt
        return;
    }
 
    // Key poll may be quite expensive, so limit it to 10 times per second.
    static auto last_poll = std::chrono::steady_clock::now();
    auto now = std::chrono::steady_clock::now();
    int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
                         ( now - last_poll ).count();
 
    if( difference > 100 ) {
        handle_key_blocking_activity();
        last_poll = now;
    }
 
    // If player is performing a task and a monster is dangerously close, warn them
    // regardless of previous safemode warnings
    if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
        !u.activity.is_distraction_ignored( distraction_type::hostile_spotted_near ) ) {
        Creature *hostile_critter = is_hostile_very_close();
        if( hostile_critter != nullptr ) {
            cancel_activity_or_ignore_query( distraction_type::hostile_spotted_near,
                                             string_format( _( "The %s is dangerously close!" ),
                                                     hostile_critter->get_name() ) );
        }
    }
}

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

prompt_dangerous_tile()

bool game::prompt_dangerous_tile

(

const tripoint &

dest_loc

)

const

Definition at line 9246 of file game.cpp.

{
    std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
 
    if( !harmful_stuff.empty() &&
        !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
        return false;
    }
    if( !harmful_stuff.empty() && u.is_mounted() &&
        m.tr_at( dest_loc ).loadid == tr_ledge ) {
        add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
                 u.mounted_creature->get_name() );
        return false;
    }
    return true;
}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

quickload()

void game::quickload ( )

private

Definition at line 11812 of file game.cpp.

{
    const WORLDPTR active_world = world_generator->active_world;
    if( active_world == nullptr ) {
        return;
    }
 
    if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
        if( moves_since_last_save != 0 ) { // See if we need to reload anything
            MAPBUFFER.reset();
            overmap_buffer.clear();
            try {
                setup();
            } catch( const std::exception &err ) {
                debugmsg( "Error: %s", err.what() );
            }
            load( save_t::from_player_name( u.name ) );
        }
    } else {
        popup_getkey( _( "No saves for %s yet." ), u.name );
    }
}

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

quicksave()

void game::quicksave

(

)

Definition at line 11790 of file game.cpp.

{
    //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
    if( !moves_since_last_save ) {
        return;
    }
    add_msg( m_info, _( "Saving game, this may take a while" ) );
 
    static_popup popup;
    popup.message( "%s", _( "Saving game, this may take a while" ) );
    ui_manager::redraw();
    refresh_display();
 
    time_t now = time( nullptr ); //timestamp for start of saving procedure
 
    //perform save
    save();
    //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
    moves_since_last_save = 0;
    last_save_timestamp = now;
}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

reenter_fullscreen()

void game::reenter_fullscreen

(

)

Definition at line 545 of file game.cpp.

{
    if( was_fullscreen ) {
        if( !fullscreen ) {
            toggle_fullscreen();
        }
    }
}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

reload()

void game::reload	(	item_location &	loc,
		bool	prompt = false,
		bool	empty = true
	)

Definition at line 8829 of file game.cpp.

{
    u.ammo_location.make_dirty();
    item *it = loc.get_item();
 
    // bows etc. do not need to reload. select favorite ammo for them instead
    if( it->has_flag( "RELOAD_AND_SHOOT" ) ) {
        item::reload_option opt = u.select_ammo( *it, prompt );
        if( !opt ) {
            return;
        } else if( u.ammo_location && opt.ammo == u.ammo_location ) {
            u.ammo_location = item_location();
        } else {
            u.ammo_location = opt.ammo;
        }
        return;
    }
 
    switch( u.rate_action_reload( *it ) ) {
        case hint_rating::iffy:
            if( ( it->is_ammo_container() || it->is_magazine() ) && it->ammo_remaining() > 0 &&
                it->ammo_remaining() == it->ammo_capacity() ) {
                add_msg( m_info, _( "The %s is already fully loaded!" ), it->tname() );
                return;
            }
            if( it->is_ammo_belt() ) {
                const auto &linkage = it->type->magazine->linkage;
                if( linkage && !u.has_charges( *linkage, 1 ) ) {
                    add_msg( m_info, _( "You need at least one %s to reload the %s!" ),
                             item::nname( *linkage, 1 ), it->tname() );
                    return;
                }
            }
            if( it->is_watertight_container() && it->is_container_full() ) {
                add_msg( m_info, _( "The %s is already full!" ), it->tname() );
                return;
            }
 
        // intentional fall-through
 
        case hint_rating::cant:
            add_msg( m_info, _( "You can't reload a %s!" ), it->tname() );
            return;
 
        case hint_rating::good:
            break;
    }
 
    bool use_loc = true;
    if( !it->has_flag( "ALLOWS_REMOTE_USE" ) ) {
        it = loc.obtain( u ).get_item();
        use_loc = false;
    }
 
    // for holsters and ammo pouches try to reload any contained item
    if( it->type->can_use( "holster" ) && !it->contents.empty() ) {
        it = &it->contents.front();
    }
 
    // for bandoliers we currently defer to iuse_actor methods
    if( it->is_bandolier() ) {
        auto ptr = dynamic_cast<const bandolier_actor *>
                   ( it->type->get_use( "bandolier" )->get_actor_ptr() );
        ptr->reload( u, *it );
        return;
    }
 
    item::reload_option opt = favorite_ammo_or_select( u, *it, empty, prompt );
 
    if( opt.ammo.get_item() == nullptr ) {
        return;
    }
 
    if( opt ) {
        int moves = opt.moves();
        if( it->get_var( "dirt", 0 ) > 7800 ) {
            add_msg( m_warning, _( "You struggle to reload the fouled %s." ), it->tname() );
            moves += 2500;
        }
 
        u.assign_activity( activity_id( "ACT_RELOAD" ), moves, opt.qty() );
        if( use_loc ) {
            u.activity.targets.emplace_back( loc );
        } else {
            u.activity.targets.emplace_back( u, const_cast<item *>( opt.target ) );
        }
        u.activity.targets.push_back( std::move( opt.ammo ) );
    }
}

References _, Character::activity, add_msg(), item::reload_option::ammo, item::ammo_capacity(), player::ammo_location, item::ammo_remaining(), Character::assign_activity(), itype::can_use(), cant, item::contents, item_contents::empty(), favorite_ammo_or_select(), item_contents::front(), use_function::get_actor_ptr(), item_location::get_item(), itype::get_use(), item::get_var(), good, Character::has_charges(), item::has_flag(), iffy, item::is_ammo_belt(), item::is_ammo_container(), item::is_bandolier(), item::is_container_full(), item::is_magazine(), item::is_watertight_container(), m_info, m_warning, itype::magazine, item_location::make_dirty(), avatar_action::move(), item::reload_option::moves(), item::nname(), item_location::obtain(), pickup::prompt, ptr(), item::reload_option::qty(), player::rate_action_reload(), player::select_ammo(), item::reload_option::target, player_activity::targets, item::tname(), item::type, and u.

Referenced by inventory_item_menu(), reload_item(), and reload_wielded().

reload_item()

void game::reload_item

(

)

Definition at line 8920 of file game.cpp.

{
    item_location item_loc = inv_map_splice( [&]( const item & it ) {
        return u.rate_action_reload( it ) == hint_rating::good;
    }, _( "Reload item" ), 1, _( "You have nothing to reload." ) );
 
    if( !item_loc ) {
        add_msg( _( "Never mind." ) );
        return;
    }
 
    reload( item_loc );
}

References _, add_msg(), good, inv_map_splice(), player::rate_action_reload(), reload(), and u.

Referenced by handle_action().

reload_npcs()

void game::reload_npcs

(

)

Unloads, then loads the NPCs.

Definition at line 957 of file game.cpp.

{
    // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
    // and not invoke "on_load" for those NPCs that avoided unloading this way.
    unload_npcs();
    load_npcs();
}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

reload_tileset()

void game::reload_tileset

(

)

Definition at line 518 of file game.cpp.

{
#if defined(TILES)
    try {
        tilecontext->reinit();
        tilecontext->load_tileset( get_option<std::string>( "TILES" ), false, true );
        tilecontext->do_tile_loading_report();
    } catch( const std::exception &err ) {
        popup( _( "Loading the tileset failed: %s" ), err.what() );
    }
    g->reset_zoom();
    g->mark_main_ui_adaptor_resize();
#endif // TILES
}

References _, g, and popup().

Referenced by handle_action().

reload_weapon()

void game::reload_weapon

(

bool

try_everything = true

)

Definition at line 8944 of file game.cpp.

{
    // As a special streamlined activity, hitting reload repeatedly should:
    // Reload wielded gun
    // First reload a magazine if necessary.
    // Then load said magazine into gun.
    // Reload magazines that are compatible with the current gun.
    // Reload other guns in inventory.
    // Reload misc magazines in inventory.
    std::vector<item_location> reloadables = u.find_reloadables();
    std::sort( reloadables.begin(), reloadables.end(),
    [this]( const item_location & a, const item_location & b ) {
        const item *ap = a.get_item();
        const item *bp = b.get_item();
        // Current wielded weapon comes first.
        if( this->u.is_wielding( *bp ) ) {
            return false;
        }
        if( this->u.is_wielding( *ap ) ) {
            return true;
        }
        // Second sort by affiliation with wielded gun
        const std::set<itype_id> compatible_magazines = this->u.weapon.magazine_compatible();
        const bool mag_ap = compatible_magazines.count( ap->typeId() ) > 0;
        const bool mag_bp = compatible_magazines.count( bp->typeId() ) > 0;
        if( mag_ap != mag_bp ) {
            return mag_ap;
        }
        // Third sort by gun vs magazine,
        if( ap->is_gun() != bp->is_gun() ) {
            return ap->is_gun();
        }
        // Finally sort by speed to reload.
        return ( ap->get_reload_time() * ( ap->ammo_capacity() - ap->ammo_remaining() ) ) <
               ( bp->get_reload_time() * ( bp->ammo_capacity() - bp->ammo_remaining() ) );
    } );
    for( item_location &candidate : reloadables ) {
        std::vector<item::reload_option> ammo_list;
        u.list_ammo( *candidate.get_item(), ammo_list, false );
        if( !ammo_list.empty() ) {
            reload( candidate, false, false );
            return;
        }
    }
    // Just for testing, bail out here to avoid unwanted side effects.
    if( !try_everything ) {
        return;
    }
    // If we make it here and haven't found anything to reload, start looking elsewhere.
    vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
    turret_data turret;
    if( veh && ( turret = veh->turret_query( u.pos() ) ) && turret.can_reload() ) {
        item::reload_option opt = g->u.select_ammo( *turret.base(), true );
        if( opt ) {
            g->u.assign_activity( activity_id( "ACT_RELOAD" ), opt.moves(), opt.qty() );
            g->u.activity.targets.emplace_back( turret.base() );
            g->u.activity.targets.push_back( std::move( opt.ammo ) );
        }
        return;
    }
 
    reload_item();
}

References a, b, Character::find_reloadables(), and u.

Referenced by handle_action().

reload_wielded()

void game::reload_wielded

(

bool

prompt = false

)

Definition at line 8934 of file game.cpp.

{
    if( u.weapon.is_null() || !u.weapon.is_reloadable() ) {
        add_msg( _( "You aren't holding something you can reload." ) );
        return;
    }
    item_location item_loc = item_location( u, &u.weapon );
    reload( item_loc, prompt );
}

References _, add_msg(), item::is_null(), item::is_reloadable(), pickup::prompt, reload(), u, and Character::weapon.

Referenced by handle_action().

remoteveh()

vehicle * game::remoteveh

(

)

Returns the current remotely controlled vehicle.

Definition at line 2558 of file game.cpp.

{
    if( calendar::turn == remoteveh_cache_time ) {
        return remoteveh_cache;
    }
    remoteveh_cache_time = calendar::turn;
    std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
    if( remote_veh_string.str().empty() ||
        ( !u.has_active_bionic( bio_remote ) && !u.has_active_item( itype_remotevehcontrol ) ) ) {
        remoteveh_cache = nullptr;
    } else {
        tripoint vp;
        remote_veh_string >> vp.x >> vp.y >> vp.z;
        vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
        if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
            remoteveh_cache = veh;
        } else {
            remoteveh_cache = nullptr;
        }
    }
    return remoteveh_cache;
}

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

remove_npc_follower()

void game::remove_npc_follower

(

const character_id &

id

)

Remove follower id from follower set.

Definition at line 1962 of file game.cpp.

{
    follower_ids.erase( id );
    u.follower_ids.erase( id );
}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

remove_zombie()

void game::remove_zombie

(

const monster &

critter

)

Definition at line 5022 of file game.cpp.

{
    critter_tracker->remove( critter );
}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

replace_stair_monsters()

void game::replace_stair_monsters ( )

private

Definition at line 11310 of file game.cpp.

{
    for( auto &elem : coming_to_stairs ) {
        elem.staircount = 0;
        const tripoint pnt( elem.pos().xy(), get_levz() );
        place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
    }
 
    coming_to_stairs.clear();
}

References coming_to_stairs, get_levz(), and place_critter_around().

reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window &  window, int  height, bool  bRadiusSort  )

private

Definition at line 7411 of file game.cpp.

{
    const int width = getmaxx( window );
    for( int i = 1; i < TERMX; i++ ) {
        if( i < width ) {
            mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
            mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
                      LINE_OXOX ); // -
        }
 
        if( i < TERMY - height ) {
            mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
            mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
        }
    }
 
    mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
    mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
 
    mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
              LINE_XXXO ); // |-
    mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
              LINE_XOXX ); // -|
 
    mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
    wprintz( window, c_white, _( "Items" ) );
 
    std::string sSort;
    if( bRadiusSort ) {
        //~ Sort type: distance.
        sSort = _( "<s>ort: dist" );
    } else {
        //~ Sort type: category.
        sSort = _( "<s>ort: cat" );
    }
 
    int letters = utf8_width( sSort );
 
    shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
 
    std::vector<std::string> tokens;
    if( !sFilter.empty() ) {
        tokens.emplace_back( _( "<R>eset" ) );
    }
 
    tokens.emplace_back( _( "<E>xamine" ) );
    tokens.emplace_back( _( "<C>ompare" ) );
    tokens.emplace_back( _( "<F>ilter" ) );
    tokens.emplace_back( _( "<+/->Priority" ) );
 
    int gaps = tokens.size() + 1;
    letters = 0;
    int n = tokens.size();
    for( int i = 0; i < n; i++ ) {
        letters += utf8_width( tokens[i] ) - 2; //length ignores < >
    }
 
    int usedwidth = letters;
    const int gap_spaces = ( width - usedwidth ) / gaps;
    usedwidth += gap_spaces * gaps;
    point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
 
    for( int i = 0; i < n; i++ ) {
        pos.x += shortcut_print( window, pos, c_white, c_light_green,
                                 tokens[i] ) + gap_spaces;
    }
}

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

reset_light_level()

void game::reset_light_level

(

)

Definition at line 3919 of file game.cpp.

{
    for( float &lev : latest_lightlevels ) {
        lev = -std::numeric_limits<float>::max();
    }
}

References latest_lightlevels.

Referenced by do_turn(), and game().

reset_npc_dispositions()

void game::reset_npc_dispositions ( )

private

Definition at line 2994 of file game.cpp.

{
    for( auto elem : follower_ids ) {
        shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
        if( !npc_to_get )  {
            continue;
        }
        npc *npc_to_add = npc_to_get.get();
        npc_to_add->chatbin.missions.clear();
        npc_to_add->chatbin.missions_assigned.clear();
        npc_to_add->mission = NPC_MISSION_NULL;
        npc_to_add->chatbin.mission_selected = nullptr;
        npc_to_add->set_attitude( NPCATT_NULL );
        npc_to_add->op_of_u.anger = 0;
        npc_to_add->op_of_u.fear = 0;
        npc_to_add->op_of_u.trust = 0;
        npc_to_add->op_of_u.value = 0;
        npc_to_add->op_of_u.owed = 0;
        npc_to_add->set_fac( faction_id( "no_faction" ) );
        npc_to_add->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC,
                                     npc_to_add->global_omt_location(),
                                     npc_to_add->getID() ) );
 
    }
 
}

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

reset_zoom()

void game::reset_zoom

(

)

Definition at line 7326 of file game.cpp.

{
#if defined(TILES)
    tileset_zoom = DEFAULT_TILESET_ZOOM;
    rescale_tileset( tileset_zoom );
#endif // TILES
}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

revive_corpse()

bool game::revive_corpse	(	const tripoint &	p,
		item &	it
	)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters

p	The place where to put the revived monster.
it	The corpse item, it must be a valid corpse (see item::is_corpse).

Returns

Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 5153 of file game.cpp.

{
    if( !it.is_corpse() ) {
        debugmsg( "Tried to revive a non-corpse." );
        return false;
    }
    shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
                                          ( it.get_mtype()->id );
    monster &critter = *newmon_ptr;
    critter.init_from_item( it );
    if( critter.get_hp() < 1 ) {
        // Failed reanimation due to corpse being too burned
        return false;
    }
    if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
        it.has_flag( "QUARTERED" ) ) {
        // Failed reanimation due to corpse being butchered
        return false;
    }
 
    critter.no_extra_death_drops = true;
    critter.add_effect( effect_downed, 5_turns, num_bp );
    for( const item &component : it.components ) {
        critter.corpse_components.push_back( component );
    }
 
    if( it.get_var( "zlave" ) == "zlave" ) {
        critter.add_effect( effect_pacified, 1_turns, num_bp );
        critter.add_effect( effect_pet, 1_turns, num_bp );
    }
 
    if( it.get_var( "no_ammo" ) == "no_ammo" ) {
        for( auto &ammo : critter.ammo ) {
            ammo.second = 0;
        }
    }
 
    return place_critter_at( newmon_ptr, p );
}

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

save()

bool game::save

(

)

Returns false if saving failed.

Definition at line 3095 of file game.cpp.

{
    try {
        if( !save_player_data() ||
            !save_factions_missions_npcs() ||
            !save_artifacts() ||
            !save_maps() ||
            !get_auto_pickup().save_character() ||
            !get_auto_notes_settings().save() ||
            !get_safemode().save_character() ||
        !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
        JsonOut jsout( fout );
            uistate.serialize( jsout );
        }, _( "uistate data" ) ) ) {
            return false;
        } else {
            world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
            return true;
        }
    } catch( std::ios::failure &err ) {
        popup( _( "Failed to save game data" ) );
        return false;
    }
}

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

save_artifacts()

bool game::save_artifacts ( )

private

Definition at line 3030 of file game.cpp.

{
    std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
    return ::save_artifacts( artfilename );
}

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

save_cyborg()

void game::save_cyborg	(	item *	cyborg,
		const tripoint &	couch_pos,
		player &	installer
	)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5193 of file game.cpp.

{
    int assist_bonus = installer.get_effect_int( effect_assisted );
 
    float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
                           skill_computer,
                           skill_electronics,
                           -1 );
 
    int damage = cyborg->damage();
    int dmg_lvl = cyborg->damage_level( 4 );
    int difficulty = 12;
 
    if( damage != 0 ) {
 
        popup( _( "WARNING: Patient's body is damaged.  Difficulty of the procedure is increased by %s." ),
               dmg_lvl );
 
        // Damage of the cyborg increases difficulty
        difficulty += dmg_lvl;
    }
 
    int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
    int success = chance_of_success - rng( 1, 100 );
 
    if( !g->u.query_yn(
            _( "WARNING: %i percent chance of SEVERE damage to all body parts!  Continue anyway?" ),
            100 - static_cast<int>( chance_of_success ) ) ) {
        return;
    }
 
    if( success > 0 ) {
        add_msg( m_good, _( "Successfully removed Personality override." ) );
        add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
 
        m.i_rem( couch_pos, cyborg );
 
        const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
        shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
        tmp->normalize();
        tmp->load_npc_template( npc_cyborg );
        tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
        overmap_buffer.insert_npc( tmp );
        tmp->hurtall( dmg_lvl * 10, nullptr );
        tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
        load_npcs();
 
    } else {
        const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
                                  adjusted_skill ) );
        const int fail_type = std::min( 5, failure_level );
        switch( fail_type ) {
            case 1:
            case 2:
                add_msg( m_info, _( "The removal fails." ) );
                add_msg( m_bad, _( "The body is damaged." ) );
                cyborg->set_damage( damage + 1000 );
                break;
            case 3:
            case 4:
                add_msg( m_info, _( "The removal fails badly." ) );
                add_msg( m_bad, _( "The body is badly damaged!" ) );
                cyborg->set_damage( damage + 2000 );
                break;
            case 5:
                add_msg( m_info, _( "The removal is a catastrophe." ) );
                add_msg( m_bad, _( "The body is destroyed!" ) );
                m.i_rem( couch_pos, cyborg );
                break;
            default:
                break;
        }
 
    }
 
}

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )

private

Definition at line 3022 of file game.cpp.

{
    std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
    return write_to_file( masterfile, [&]( std::ostream & fout ) {
        serialize_master( fout );
    }, _( "factions data" ) );
}

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

save_maps()

bool game::save_maps ( )

private

Definition at line 3036 of file game.cpp.

{
    try {
        m.save();
        overmap_buffer.save(); // can throw
        MAPBUFFER.save(); // can throw
        return true;
    } catch( const std::exception &err ) {
        popup( _( "Failed to save the maps: %s" ), err.what() );
        return false;
    }
}

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

save_player_data()

bool game::save_player_data ( )

private

Definition at line 3049 of file game.cpp.

{
    const std::string playerfile = get_player_base_save_path();
 
    const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
        serialize( fout );
    }, _( "player data" ) );
    const bool saved_map_memory = u.save_map_memory();
    const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
    std::ostream & fout ) {
        fout << memorial().dump();
    }, _( "player memorial" ) );
#if defined(__ANDROID__)
    const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
    std::ostream & fout ) {
        save_shortcuts( fout );
    }, _( "quick shortcuts" ) );
#endif
 
    return saved_data && saved_map_memory && saved_log
#if defined(__ANDROID__)
           && saved_shortcuts
#endif
           ;
}

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

serialize()

void game::serialize

(

std::ostream &

fout

)

Saving and loading functions.

Definition at line 71 of file savegame.cpp.

{
    /*
     * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
     * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
     */
    // Header
    fout << "# version " << savegame_version << std::endl;
 
    JsonOut json( fout, true ); // pretty-print
 
    json.start_object();
    // basic game state information.
    json.member( "turn", calendar::turn );
    const calendar_config &calendar_config = calendar::config;
    json.member( "calendar_start", calendar_config._start_of_cataclysm );
    json.member( "game_start", calendar_config._start_of_game );
    json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
    json.member( "auto_travel_mode", auto_travel_mode );
    json.member( "run_mode", static_cast<int>( safe_mode ) );
    json.member( "mostseen", mostseen );
    // current map coordinates
    tripoint pos_sm = m.get_abs_sub();
    const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
    json.member( "levx", pos_sm.x );
    json.member( "levy", pos_sm.y );
    json.member( "levz", pos_sm.z );
    json.member( "om_x", pos_om.x );
    json.member( "om_y", pos_om.y );
 
    json.member( "grscent", scent.serialize() );
    json.member( "typescent", scent.serialize( true ) );
 
    // Then each monster
    json.member( "active_monsters", *critter_tracker );
    json.member( "stair_monsters", coming_to_stairs );
 
    // save stats.
    json.member( "kill_tracker", *kill_tracker_ptr );
    json.member( "stats_tracker", *stats_tracker_ptr );
    json.member( "achievements_tracker", *achievements_tracker_ptr );
 
    json.member( "token_provider", *token_provider_ptr );
 
    json.member( "player", u );
    Messages::serialize( json );
 
    json.end_object();
}

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

serialize_master()

void game::serialize_master ( std::ostream &  fout )

private

Definition at line 1259 of file savegame.cpp.

{
    fout << "# version " << savegame_version << std::endl;
    try {
        JsonOut json( fout, true ); // pretty-print
        json.start_object();
 
        json.member( "next_mission_id", next_mission_id );
        json.member( "next_npc_id", next_npc_id );
 
        json.member( "active_missions" );
        mission::serialize_all( json );
 
        json.member( "factions", *faction_manager_ptr );
        json.member( "seed", seed );
 
        json.member( "weather" );
        json.start_object();
        json.member( "lightning", get_weather().lightning_active );
        json.end_object();
 
        json.end_object();
    } catch( const JsonError &e ) {
        debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
    }
}

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

set_critter_died()

void game::set_critter_died

(

)

If invoked, dead will be cleaned this turn.

Definition at line 1871 of file game.cpp.

{
    critter_died = true;
}

References critter_died.

set_driving_view_offset()

void game::set_driving_view_offset

(

const point &

p

)

Definition at line 1688 of file game.cpp.

{
    // remove the previous driving offset,
    // store the new offset and apply the new offset.
    u.view_offset.x -= driving_view_offset.x;
    u.view_offset.y -= driving_view_offset.y;
    driving_view_offset.x = p.x;
    driving_view_offset.y = p.y;
    u.view_offset.x += driving_view_offset.x;
    u.view_offset.y += driving_view_offset.y;
}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

set_npcs_dirty()

void game::set_npcs_dirty

(

)

If invoked, NPCs will be reloaded before next turn.

Definition at line 1866 of file game.cpp.

{
    npcs_dirty = true;
}

References npcs_dirty.

set_safe_mode()

void game::set_safe_mode

(

safe_mode_type

mode

)

Definition at line 9174 of file game.cpp.

{
    safe_mode = mode;
    safe_mode_warning_logged = false;
}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

set_zoom()

void game::set_zoom

(

int

level

)

Definition at line 7334 of file game.cpp.

{
#if defined(TILES)
    if( tileset_zoom != level ) {
        tileset_zoom = level;
        rescale_tileset( tileset_zoom );
    }
#else
    static_cast<void>( level );
#endif // TILES
}

References tileset_zoom.

Referenced by look_around().

setremoteveh()

void game::setremoteveh

(

vehicle *

veh

)

Sets the current remotely controlled vehicle.

Definition at line 2581 of file game.cpp.

{
    remoteveh_cache_time = calendar::turn;
    remoteveh_cache = veh;
    if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
        !u.has_active_item( itype_remotevehcontrol ) ) {
        debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
        veh = nullptr;
    }
 
    if( veh == nullptr ) {
        u.remove_value( "remote_controlling_vehicle" );
        return;
    }
 
    std::stringstream remote_veh_string;
    const tripoint vehpos = veh->global_pos3();
    remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
    u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
}

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

setup()

void game::setup

(

)

Definition at line 557 of file game.cpp.

{
    loading_ui ui( true );
    {
        background_pane background;
        static_popup popup;
        popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
        ui_manager::redraw();
        refresh_display();
 
        load_core_data( ui );
    }
 
    load_world_modfiles( ui );
 
    if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
        debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
    }
 
    m = map( get_option<bool>( "ZLEVELS" ) );
 
    next_npc_id = character_id( 1 );
    next_mission_id = 1;
    new_game = true;
    uquit = QUIT_NO;   // We haven't quit the game
    bVMonsterLookFire = true;
 
    // invalidate calendar caches in case we were previously playing
    // a different world
    calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
    calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
 
    get_weather().weather_id = weather_type_id::NULL_ID();
    get_weather().nextweather = calendar::before_time_starts;
 
    turnssincelastmon = 0; //Auto safe mode init
 
    sounds::reset_sounds();
    clear_zombies();
    coming_to_stairs.clear();
    active_npc.clear();
    faction_manager_ptr->clear();
    mission::clear_all();
    Messages::clear_messages();
    timed_events = timed_event_manager();
    explosion_handler::get_explosion_queue().clear();
 
    SCT.vSCT.clear(); //Delete pending messages
 
    stats().clear();
    // reset kill counts
    kill_tracker_ptr->clear();
    achievements_tracker_ptr->clear();
    // reset follower list
    follower_ids.clear();
    scent.reset();
 
    remoteveh_cache_time = calendar::before_time_starts;
    remoteveh_cache = nullptr;
 
    token_provider_ptr->clear();
    // back to menu for save loading, new game etc
}

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

shared_from()

template<typename T >

template shared_ptr_fast< npc > game::shared_from< npc >

(

const T &

critter

)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4880 of file game.cpp.

{
    if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
        // u is not stored in a shared_ptr, but it won't go out of scope anyway
        return std::dynamic_pointer_cast<T>( u_shared_ptr );
    }
    if( critter.is_monster() ) {
        if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
            if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
                return std::dynamic_pointer_cast<T>( mon_ptr );
            }
        }
    }
    if( critter.is_npc() ) {
        for( auto &cur_npc : active_npc ) {
            if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
                return std::dynamic_pointer_cast<T>( cur_npc );
            }
        }
    }
    return nullptr;
}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

shift_destination_preview()

void game::shift_destination_preview

(

const point &

delta

)

Definition at line 12539 of file game.cpp.

{
    for( tripoint &p : destination_preview ) {
        p += delta;
    }
}

References destination_preview.

shift_monsters()

void game::shift_monsters ( const tripoint &  shift )

private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11545 of file game.cpp.

{
    // If either shift argument is non-zero, we're shifting.
    if( shift == tripoint_zero ) {
        return;
    }
    for( monster &critter : all_monsters() ) {
        if( shift.xy() != point_zero ) {
            critter.shift( shift.xy() );
        }
 
        if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
            // We're inbounds, so don't despawn after all.
            // No need to shift Z-coordinates, they are absolute
            continue;
        }
        // Either a vertical shift or the critter is now outside of the reality bubble,
        // anyway: it must be saved and removed.
        despawn_monster( critter );
    }
    // The order in which zombies are shifted may cause zombies to briefly exist on
    // the same square. This messes up the mon_at cache, so we need to rebuild it.
    critter_tracker->rebuild_cache();
}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

slip_down()

bool game::slip_down

(

)

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns

whether player has slipped down

Dexterity decreases chances of slipping while climbing

Definition at line 12546 of file game.cpp.

{
    ///\EFFECT_DEX decreases chances of slipping while climbing
    int climb = u.dex_cur;
    if( u.has_trait( trait_BADKNEES ) ) {
        climb = climb / 2;
    }
    if( one_in( climb ) ) {
        add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
        if( climb <= 1 ) {
            add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
        }
        return true;
    }
    return false;
}

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

spawn_hallucination()

bool game::spawn_hallucination

(

const tripoint &

p

)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns

Whether or not a hallucination was successfully spawned.

Definition at line 5038 of file game.cpp.

{
    if( one_in( 100 ) ) {
        shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
        tmp->normalize();
        tmp->randomize( NC_HALLU );
        tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
        if( !critter_at( p, true ) ) {
            overmap_buffer.insert_npc( tmp );
            load_npcs();
            return true;
        } else {
            return false;
        }
    }
 
    const mtype_id &mt = MonsterGenerator::generator().get_valid_hallucination();
    const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
    phantasm->hallucination = true;
    phantasm->spawn( p );
 
    //Don't attempt to place phantasms inside of other creatures
    if( !critter_at( phantasm->pos(), true ) ) {
        return critter_tracker->add( phantasm );
    } else {
        return false;
    }
}

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

spell_events_subscriber()

spell_events & game::spell_events_subscriber

(

)

Definition at line 3090 of file game.cpp.

{
    return *spell_events_ptr;
}

References spell_events_ptr.

start_calendar()

void game::start_calendar

(

)

Definition at line 12108 of file game.cpp.

{
    const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
                             scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
                             scen->has_flag( "SUM_ADV_START" );
 
    calendar_config &calendar_config = calendar::config;
    if( scen_season ) {
        // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
        calendar_config._start_of_cataclysm = calendar::turn_zero + 1_hours *
                                              get_option<int>( "INITIAL_TIME" );
        calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
        if( scen->has_flag( "SPR_START" ) ) {
            calendar_config._initial_season = SPRING;
        } else if( scen->has_flag( "SUM_START" ) ) {
            calendar_config._initial_season = SUMMER;
            calendar_config._start_of_game += calendar_config.season_length();
        } else if( scen->has_flag( "AUT_START" ) ) {
            calendar_config._initial_season = AUTUMN;
            calendar_config._start_of_game += calendar_config.season_length() * 2;
        } else if( scen->has_flag( "WIN_START" ) ) {
            calendar_config._initial_season = WINTER;
            calendar_config._start_of_game += calendar_config.season_length() * 3;
        } else if( scen->has_flag( "SUM_ADV_START" ) ) {
            calendar_config._initial_season = SUMMER;
            calendar_config._start_of_game += calendar_config.season_length() * 5;
        } else {
            debugmsg( "The Unicorn" );
        }
    } else {
        // No scenario, so use the starting date+time configured in world options
        int initial_days = get_option<int>( "INITIAL_DAY" );
        if( initial_days == -1 ) {
            // 0 - 363 for a 91 day season
            initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
        }
        calendar_config._start_of_cataclysm = calendar::turn_zero + 1_days * initial_days;
 
        // Determine the season based off how long the seasons are set to be
        // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
        const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
        if( season_number == 0 ) {
            calendar_config._initial_season = SPRING;
        } else if( season_number == 1 ) {
            calendar_config._initial_season = SUMMER;
        } else if( season_number == 2 ) {
            calendar_config._initial_season = AUTUMN;
        } else {
            calendar_config._initial_season = WINTER;
        }
 
        calendar_config._start_of_game = calendar_config._start_of_cataclysm
                                         + 1_hours * get_option<int>( "INITIAL_TIME" )
                                         + 1_days * get_option<int>( "SPAWN_DELAY" );
    }
 
    calendar::turn = calendar_config._start_of_game;
}

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

start_game()

bool game::start_game ( )

private

Definition at line 644 of file game.cpp.

{
    if( !gamemode ) {
        gamemode = std::make_unique<special_game>();
    }
 
    seed = rng_bits();
    new_game = true;
    start_calendar();
    get_weather().nextweather = calendar::turn;
    safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
    mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
    get_safemode().load_global();
 
    init_autosave();
 
    background_pane background;
    static_popup popup;
    popup.message( "%s", _( "Please wait as we build your world" ) );
    ui_manager::redraw();
    refresh_display();
 
    load_master();
    u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
 
    const start_location &start_loc = u.random_start_location ? scen->random_start_location().obj() :
                                      u.start_location.obj();
    tripoint_abs_omt omtstart = overmap::invalid_tripoint;
    do {
        omtstart = start_loc.find_player_initial_location();
        if( omtstart == overmap::invalid_tripoint ) {
            if( query_yn(
                    _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
                MAPBUFFER.reset();
                overmap_buffer.clear();
            } else {
                return false;
            }
        }
    } while( omtstart == overmap::invalid_tripoint );
 
    start_loc.prepare_map( omtstart );
 
    // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
    if( u.starting_vehicle &&
        !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
                               std::vector<std::string> {} ) ) {
        debugmsg( "could not place starting vehicle" );
    }
 
    if( scen->has_map_extra() ) {
        // Map extras can add monster spawn points and similar and should be done before the main
        // map is loaded.
        start_loc.add_map_extra( omtstart, scen->get_map_extra() );
    }
 
    // TODO: fix point types
    tripoint lev = project_to<coords::sm>( omtstart ).raw();
    // The player is centered in the map, but lev[xyz] refers to the top left point of the map
    lev.x -= HALF_MAPSIZE;
    lev.y -= HALF_MAPSIZE;
    load_map( lev );
 
    m.invalidate_map_cache( get_levz() );
    m.build_map_cache( get_levz() );
    // Do this after the map cache has been built!
    start_loc.place_player( u );
    // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
    m.invalidate_map_cache( get_levz() );
    m.build_map_cache( get_levz() );
    // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
    overmap_buffer.reveal( u.global_omt_location().xy(),
                           get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
 
    u.moves = 0;
    u.process_turn(); // process_turn adds the initial move points
    u.set_stamina( u.get_stamina_max() );
    get_weather().temperature = SPRING_TEMPERATURE;
    get_weather().update_weather();
    u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
    u.last_climate_control_ret = false;
 
    //Reset character safe mode/pickup rules
    get_auto_pickup().clear_character_rules();
    get_safemode().clear_character_rules();
    get_auto_notes_settings().clear();
    get_auto_notes_settings().default_initialize();
 
    //Put some NPCs in there!
    if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
        ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
          !g->scen->has_flag( "LONE_START" ) ) ) {
        create_starting_npcs();
    }
    //Load NPCs. Set nearby npcs to active.
    load_npcs();
    // Spawn the monsters
    const bool spawn_near =
        get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
    // Surrounded start ones
    if( spawn_near ) {
        start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
    }
 
    m.spawn_monsters( !spawn_near ); // Static monsters
 
    // Make sure that no monsters are near the player
    // This can happen in lab starts
    if( !spawn_near ) {
        for( monster &critter : all_monsters() ) {
            if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
                m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
                remove_zombie( critter );
            }
        }
    }
 
    //Create mutation_category_level
    u.set_highest_cat_level();
    //Calculate mutation drench protection stats
    u.drench_mut_calc();
    u.add_effect( effect_accumulated_mutagen, 27_days, num_bp );
    if( scen->has_flag( "FIRE_START" ) ) {
        start_loc.burn( omtstart, 3, 3 );
    }
    if( scen->has_flag( "INFECTED" ) ) {
        u.add_effect( effect_infected, 1_turns, random_body_part() );
    }
    if( scen->has_flag( "BAD_DAY" ) ) {
        u.add_effect( effect_flu, 1000_minutes );
        u.add_effect( effect_drunk, 270_minutes );
        u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
    }
    if( scen->has_flag( "HELI_CRASH" ) ) {
        start_loc.handle_heli_crash( u );
        bool success = false;
        for( auto v : m.get_vehicles() ) {
            std::string name = v.v->type.str();
            std::string search = std::string( "helicopter" );
            if( name.find( search ) != std::string::npos ) {
                for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
                    const tripoint pos = vp.pos();
                    u.setpos( pos );
 
                    // Delete the items that would have spawned here from a "corpse"
                    for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
                        vehicle_stack here = v.v->get_items( sp );
 
                        for( auto iter = here.begin(); iter != here.end(); ) {
                            iter = here.erase( iter );
                        }
                    }
 
                    auto mons = critter_tracker->find( pos );
                    if( mons != nullptr ) {
                        critter_tracker->remove( *mons );
                    }
 
                    success = true;
                    break;
                }
                if( success ) {
                    v.v->name = "Bird Wreckage";
                    break;
                }
            }
        }
    }
    if( scen->has_flag( "BORDERED" ) ) {
        overmap &starting_om = get_cur_om();
        for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
            starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
                                              om_direction::type::north );
        }
 
    }
    for( auto &e : u.inv_dump() ) {
        e->set_owner( g->u );
    }
    // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
    update_map( u );
    // Profession pets
    for( const mtype_id &elem : u.starting_pets ) {
        if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
            mon->friendly = -1;
            mon->add_effect( effect_pet, 1_turns, num_bp );
        } else {
            add_msg( m_debug, "cannot place starting pet, no space!" );
        }
    }
    // Assign all of this scenario's missions to the player.
    for( const mission_type_id &m : scen->missions() ) {
        const auto mission = mission::reserve_new( m, character_id() );
        mission->assign( u );
    }
 
    g->events().send<event_type::game_start>( u.getID() );
    return true;
}

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

start_hauling()

void game::start_hauling

(

const tripoint &

pos

)

Definition at line 10908 of file game.cpp.

{
    // Find target items and quantities thereof for the new activity
    std::vector<item_location> target_items;
    std::vector<int> quantities;
 
    map_stack items = m.i_at( pos );
    for( item &it : items ) {
        // Liquid cannot be picked up
        if( it.made_of( LIQUID ) ) {
            continue;
        }
        target_items.emplace_back( map_cursor( pos ), &it );
        // Quantity of 0 means move all
        quantities.push_back( 0 );
    }
 
    if( target_items.empty() ) {
        // Nothing to haul
        return;
    }
 
    // Whether the destination is inside a vehicle (not supported)
    const bool to_vehicle = false;
    // Destination relative to the player
    const tripoint relative_destination{};
 
    u.assign_activity( player_activity( move_items_activity_actor(
                                            target_items,
                                            quantities,
                                            to_vehicle,
                                            relative_destination
                                        ) ) );
}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

stats()

stats_tracker & game::stats

(

)

Definition at line 3080 of file game.cpp.

{
    return *stats_tracker_ptr;
}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

swap_critters()

bool game::swap_critters	(	Creature &	a,
		Creature &	b
	)

Swaps positions of two creatures.

Definition at line 5067 of file game.cpp.

{
    if( &a == &b ) {
        // No need to do anything, but print a debugmsg anyway
        debugmsg( "Tried to swap %s with itself", a.disp_name() );
        return true;
    }
    if( critter_at( a.pos() ) != &a ) {
        debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
                  b.disp_name(), critter_at( a.pos() )->disp_name() );
        return false;
    }
    if( critter_at( b.pos() ) != &b ) {
        debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
                  a.disp_name(), critter_at( b.pos() )->disp_name() );
        return false;
    }
    // Simplify by "sorting" the arguments
    // Only the first argument can be u
    // If swapping player/npc with a monster, monster is second
    bool a_first = a.is_player() ||
                   ( a.is_npc() && !b.is_player() );
    Creature &first  = a_first ? a : b;
    Creature &second = a_first ? b : a;
    // Possible options:
    // both first and second are monsters
    // second is a monster, first is a player or an npc
    // first is a player, second is an npc
    // both first and second are npcs
    if( first.is_monster() ) {
        monster *m1 = dynamic_cast< monster * >( &first );
        monster *m2 = dynamic_cast< monster * >( &second );
        if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
            debugmsg( "Couldn't swap two monsters" );
            return false;
        }
 
        critter_tracker->swap_positions( *m1, *m2 );
        return true;
    }
 
    player *u_or_npc = dynamic_cast< player * >( &first );
    player *other_npc = dynamic_cast< player * >( &second );
 
    if( u_or_npc->in_vehicle ) {
        g->m.unboard_vehicle( u_or_npc->pos() );
    }
 
    if( other_npc && other_npc->in_vehicle ) {
        g->m.unboard_vehicle( other_npc->pos() );
    }
 
    tripoint temp = second.pos();
    second.setpos( first.pos() );
 
    if( first.is_player() ) {
        g->walk_move( temp );
    } else {
        first.setpos( temp );
        if( g->m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
            g->m.board_vehicle( u_or_npc->pos(), u_or_npc );
        }
    }
 
    if( other_npc && g->m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
        g->m.board_vehicle( other_npc->pos(), other_npc );
    }
    return true;
}

References a, b, critter_at(), critter_tracker, debugmsg, g, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), Creature::pos(), Character::pos(), second, Creature::setpos(), and VPFLAG_BOARDABLE.

Referenced by npc_menu().

take_screenshot() [1/2]

bool game::take_screenshot

(

)

const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note

: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.

Returns

true if the screenshot generation was successful, false otherwise.

Definition at line 7403 of file game.cpp.

{
    popup( _( "This binary was not compiled with tiles support." ) );
    return false;
}

References _, and popup().

Referenced by do_turn().

take_screenshot() [2/2]

bool game::take_screenshot

(

const std::string &

file_path

)

const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters

file_path

A full path to the file where the screenshot should be saved.

Note

: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.

Returns

true if the screenshot generation was successful, false otherwise.

Definition at line 7397 of file game.cpp.

{
    popup( _( "This binary was not compiled with tiles support." ) );
    return false;
}

References _, and popup().

temp_exit_fullscreen()

void game::temp_exit_fullscreen

(

)

Definition at line 535 of file game.cpp.

{
    if( fullscreen ) {
        was_fullscreen = true;
        toggle_fullscreen();
    } else {
        was_fullscreen = false;
    }
}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

toggle_debug_hour_timer()

void game::toggle_debug_hour_timer

(

)

Definition at line 11716 of file game.cpp.

{
    debug_hour_timer.toggle();
}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

toggle_fullscreen()

void game::toggle_fullscreen

(

)

Definition at line 497 of file game.cpp.

{
#if !defined(TILES)
    fullscreen = !fullscreen;
    mark_main_ui_adaptor_resize();
#else
    toggle_fullscreen_window();
#endif
}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

toggle_pixel_minimap()

void game::toggle_pixel_minimap

(

)

Definition at line 507 of file game.cpp.

{
#if defined(TILES)
    if( pixel_minimap_option ) {
        clear_window_area( w_pixel_minimap );
    }
    pixel_minimap_option = !pixel_minimap_option;
    mark_main_ui_adaptor_resize();
#endif // TILES
}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

try_get_left_click_action()

bool game::try_get_left_click_action ( action_id &  act, const tripoint &  mouse_target  )

private

Definition at line 2602 of file game.cpp.

{
    bool new_destination = true;
    if( !destination_preview.empty() ) {
        auto &final_destination = destination_preview.back();
        if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
            // Second click
            new_destination = false;
            u.set_destination( destination_preview );
            destination_preview.clear();
            act = u.get_next_auto_move_direction();
            if( act == ACTION_NULL ) {
                // Something went wrong
                u.clear_destination();
                return false;
            }
        }
    }
 
    if( new_destination ) {
        destination_preview = m.route( u.pos(), mouse_target, u.get_pathfinding_settings(),
                                       u.get_path_avoid() );
        return false;
    }
 
    return true;
}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

try_get_right_click_action()

bool game::try_get_right_click_action ( action_id &  act, const tripoint &  mouse_target  )

private

Definition at line 2630 of file game.cpp.

{
    const bool cleared_destination = !destination_preview.empty();
    u.clear_destination();
    destination_preview.clear();
 
    if( cleared_destination ) {
        // Produce no-op if auto-move had just been cleared on this action
        // e.g. from a previous single left mouse click. This has the effect
        // of right-click canceling an auto-move before it is initiated.
        return false;
    }
 
    const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
    const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
    if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
        if( !u.sees( *mon ) ) {
            add_msg( _( "Nothing relevant here." ) );
            return false;
        }
 
        if( !u.weapon.is_gun() ) {
            add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
            return false;
        }
 
        // TODO: Add weapon range check. This requires weapon to be reloaded.
 
        act = ACTION_FIRE;
    } else if( is_adjacent &&
               m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
                             true ) ) {
        act = ACTION_CLOSE;
    } else if( is_self ) {
        act = ACTION_PICKUP;
    } else if( is_adjacent ) {
        act = ACTION_EXAMINE;
    } else {
        add_msg( _( "Nothing relevant here." ) );
        return false;
    }
 
    return true;
}

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

unload()

bool game::unload

(

item_location

loc

)

Definition at line 9008 of file game.cpp.

{
    return u.unload( loc );
}

References u, and player::unload().

Referenced by inventory_item_menu().

unload_npcs()

void game::unload_npcs ( )

private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 948 of file game.cpp.

{
    for( const auto &npc : active_npc ) {
        npc->on_unload();
    }
 
    active_npc.clear();
}

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

unserialize()

void game::unserialize

(

std::istream &

fin

)

Definition at line 169 of file savegame.cpp.

{
    chkversion( fin );
    int tmpturn = 0;
    int tmpcalstart = 0;
    int tmprun = 0;
    tripoint lev;
    point com;
    JsonIn jsin( fin );
    try {
        JsonObject data = jsin.get_object();
 
        data.read( "turn", tmpturn );
        data.read( "calendar_start", tmpcalstart );
        calendar_config &calendar_config = calendar::config;
        calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
                                          static_cast<int>( SPRING ) ) );
        // 0.E stable
        if( savegame_loading_version < 26 ) {
            tmpturn *= 6;
            tmpcalstart *= 6;
        }
        calendar::turn = calendar::turn_zero + time_duration::from_turns( tmpturn );
        calendar_config._start_of_cataclysm = calendar::turn_zero + time_duration::from_turns(
                tmpcalstart );
 
        if( !data.read( "game_start", calendar_config._start_of_game ) ) {
            calendar_config._start_of_game = calendar_config._start_of_cataclysm;
        }
 
        data.read( "auto_travel_mode", auto_travel_mode );
        data.read( "run_mode", tmprun );
        data.read( "mostseen", mostseen );
        data.read( "levx", lev.x );
        data.read( "levy", lev.y );
        data.read( "levz", lev.z );
        data.read( "om_x", com.x );
        data.read( "om_y", com.y );
 
        load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
 
        safe_mode = static_cast<safe_mode_type>( tmprun );
        if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
            safe_mode = SAFE_MODE_ON;
        }
 
        std::string linebuff;
        std::string linebuf;
        if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
            scent.deserialize( linebuf );
            scent.deserialize( linebuff, true );
        } else {
            scent.reset();
        }
        data.read( "active_monsters", *critter_tracker );
 
        coming_to_stairs.clear();
        for( auto elem : data.get_array( "stair_monsters" ) ) {
            monster stairtmp;
            elem.read( stairtmp );
            coming_to_stairs.push_back( stairtmp );
        }
 
        if( data.has_object( "kill_tracker" ) ) {
            data.read( "kill_tracker", *kill_tracker_ptr );
        } else {
            // Legacy support for when kills were stored directly in game
            std::map<mtype_id, int> kills;
            std::vector<std::string> npc_kills;
            for( const JsonMember member : data.get_object( "kills" ) ) {
                kills[mtype_id( member.name() )] = member.get_int();
            }
 
            for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
                npc_kills.push_back( npc_name );
            }
 
            kill_tracker_ptr->reset( kills, npc_kills );
        }
 
        data.read( "player", u );
        data.read( "stats_tracker", *stats_tracker_ptr );
        data.read( "achievements_tracker", *achievements_tracker_ptr );
        data.read( "token_provider", token_provider_ptr );
        Messages::deserialize( data );
 
    } catch( const JsonError &jsonerr ) {
        debugmsg( "Bad save json\n%s", jsonerr.c_str() );
        return;
    }
}

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

unserialize_master()

void game::unserialize_master

(

std::istream &

fin

)

Definition at line 1209 of file savegame.cpp.

{
    savegame_loading_version = 0;
    chkversion( fin );
    if( savegame_loading_version < 11 ) {
        std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
        popup->message(
            _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
            savegame_loading_version, savegame_version );
        ui_manager::redraw();
        refresh_display();
    }
    try {
        // single-pass parsing example
        JsonIn jsin( fin );
        jsin.start_object();
        while( !jsin.end_object() ) {
            std::string name = jsin.get_member_name();
            if( name == "next_mission_id" ) {
                next_mission_id = jsin.get_int();
            } else if( name == "next_npc_id" ) {
                next_npc_id.deserialize( jsin );
            } else if( name == "active_missions" ) {
                mission::unserialize_all( jsin );
            } else if( name == "factions" ) {
                jsin.read( *faction_manager_ptr );
            } else if( name == "seed" ) {
                jsin.read( seed );
            } else if( name == "weather" ) {
                JsonObject w = jsin.get_object();
                w.read( "lightning", get_weather().lightning_active );
            } else {
                // silently ignore anything else
                jsin.skip_value();
            }
        }
    } catch( const JsonError &e ) {
        debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
    }
}

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

update_map() [1/2]

point game::update_map	(	int &	x,
		int &	y
	)

Definition at line 11176 of file game.cpp.

{
    point shift;
 
    while( x < HALF_MAPSIZE_X ) {
        x += SEEX;
        shift.x--;
    }
    while( x >= HALF_MAPSIZE_X + SEEX ) {
        x -= SEEX;
        shift.x++;
    }
    while( y < HALF_MAPSIZE_Y ) {
        y += SEEY;
        shift.y--;
    }
    while( y >= HALF_MAPSIZE_Y + SEEY ) {
        y -= SEEY;
        shift.y++;
    }
 
    if( shift == point_zero ) {
        // adjust player position
        u.setpos( tripoint( x, y, get_levz() ) );
        // Update what parts of the world map we can see
        // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
        // TODO: only make this call if we changed z-level
        update_overmap_seen();
        // Not actually shifting the submaps, all the stuff below would do nothing
        return point_zero;
    }
 
    // this handles loading/unloading submaps that have scrolled on or off the viewport
    // NOLINTNEXTLINE(cata-use-named-point-constants)
    inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
    point remaining_shift = shift;
    while( remaining_shift != point_zero ) {
        point this_shift = clamp( remaining_shift, size_1 );
        m.shift( this_shift );
        remaining_shift -= this_shift;
    }
 
    grid_tracker_ptr->load( m );
 
    // Shift monsters
    shift_monsters( tripoint( shift, 0 ) );
    const point shift_ms = sm_to_ms_copy( shift );
    u.shift_destination( -shift_ms );
 
    // Shift NPCs
    for( auto it = active_npc.begin(); it != active_npc.end(); ) {
        ( *it )->shift( shift );
        if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
            ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
            //Remove the npc from the active list. It remains in the overmap list.
            ( *it )->on_unload();
            it = active_npc.erase( it );
        } else {
            it++;
        }
    }
 
    scent.shift( shift_ms );
 
    // Also ensure the player is on current z-level
    // get_levz() should later be removed, when there is no longer such a thing
    // as "current z-level"
    u.setpos( tripoint( x, y, get_levz() ) );
 
    // Only do the loading after all coordinates have been shifted.
 
    // Check for overmap saved npcs that should now come into view.
    // Put those in the active list.
    load_npcs();
 
    // Make sure map cache is consistent since it may have shifted.
    if( m.has_zlevels() ) {
        for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
            m.invalidate_map_cache( zlev );
        }
    } else {
        m.invalidate_map_cache( get_levz() );
    }
    m.build_map_cache( get_levz() );
 
    // Spawn monsters if appropriate
    // This call will generate new monsters in addition to loading, so it's placed after NPC loading
    m.spawn_monsters( false ); // Static monsters
 
    // Update what parts of the world map we can see
    update_overmap_seen();
 
    return shift;
}

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

update_map() [2/2]

point game::update_map

(

player &

p

)

Definition at line 11170 of file game.cpp.

{
    point p2( p.posx(), p.posy() );
    return update_map( p2.x, p2.y );
}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

update_overmap_seen()

void game::update_overmap_seen

(

)

Definition at line 11271 of file game.cpp.

{
    const tripoint_abs_omt ompos = u.global_omt_location();
    const int dist = u.overmap_sight_range( light_level( u.posz() ) );
    const int dist_squared = dist * dist;
    // We can always see where we're standing
    overmap_buffer.set_seen( ompos, true );
    for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
        const point_rel_omt delta = p.xy() - ompos.xy();
        const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
        if( trigdist && h_squared > dist_squared ) {
            continue;
        }
        if( delta == point_rel_omt() ) {
            // 1. This case is already handled outside of the loop
            // 2. Calculating multiplier would cause division by zero
            continue;
        }
        // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
        point abs_delta = delta.raw().abs();
        int max_delta = std::max( abs_delta.x, abs_delta.y );
        const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
        const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
        float sight_points = dist;
        for( auto it = line.begin();
             it != line.end() && sight_points >= 0; ++it ) {
            const oter_id &ter = overmap_buffer.ter( *it );
            sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
        }
        if( sight_points >= 0 ) {
            tripoint_abs_omt seen( p );
            do {
                overmap_buffer.set_seen( seen, true );
                --seen.z();
            } while( seen.z() >= 0 );
        }
    }
}

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

update_stair_monsters()

void game::update_stair_monsters ( )

private

Dodge reduces chance of being downed when pushed off the stairs

Definition at line 11323 of file game.cpp.

{
    // Search for the stairs closest to the player.
    std::vector<int> stairx;
    std::vector<int> stairy;
    std::vector<int> stairdist;
 
    const bool from_below = monstairz < get_levz();
 
    if( coming_to_stairs.empty() ) {
        return;
    }
 
    if( m.has_zlevels() ) {
        debugmsg( "%d monsters coming to stairs on a map with z-levels",
                  coming_to_stairs.size() );
        coming_to_stairs.clear();
    }
 
    for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
        if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
            ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
            stairx.push_back( dest.x );
            stairy.push_back( dest.y );
            stairdist.push_back( rl_dist( dest, u.pos() ) );
        }
    }
    if( stairdist.empty() ) {
        return;         // Found no stairs?
    }
 
    // Find closest stairs.
    size_t si = 0;
    for( size_t i = 0; i < stairdist.size(); i++ ) {
        if( stairdist[i] < stairdist[si] ) {
            si = i;
        }
    }
 
    // Find up to 4 stairs for distance stairdist[si] +1
    std::vector<int> nearest;
    nearest.push_back( si );
    for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
        if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
            nearest.push_back( i );
        }
    }
    // Randomize the stair choice
    si = random_entry_ref( nearest );
 
    // Attempt to spawn zombies.
    for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
        point mpos( stairx[si], stairy[si] );
        monster &critter = coming_to_stairs[i];
        const tripoint dest {
            mpos, g->get_levz()
        };
 
        // We might be not be visible.
        if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
              critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
              critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
              critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
            continue;
        }
 
        critter.staircount -= 4;
        // Let the player know zombies are trying to come.
        if( u.sees( dest ) ) {
            std::string dump;
            if( critter.staircount > 4 ) {
                dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
            } else {
                if( critter.staircount > 0 ) {
                    dump += ( from_below ?
                              //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
                              string_format( _( "The %1$s is almost at the top of the %2$s!" ),
                                             critter.name(),
                                             m.tername( dest ) ) :
                              string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
                                             critter.name(),
                                             m.tername( dest ) ) );
                }
            }
 
            add_msg( m_warning, dump );
        } else {
            sounds::sound( dest, 5, sounds::sound_t::movement,
                           _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
        }
 
        if( critter.staircount > 0 ) {
            continue;
        }
 
        if( is_empty( dest ) ) {
            critter.spawn( dest );
            critter.staircount = 0;
            place_critter_at( make_shared_fast<monster>( critter ), dest );
            if( u.sees( dest ) ) {
                if( !from_below ) {
                    add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
                             critter.name(),
                             m.tername( dest ) );
                } else {
                    add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
                             critter.name(),
                             m.tername( dest ) );
                }
            }
            coming_to_stairs.erase( coming_to_stairs.begin() + i );
            continue;
        } else if( u.pos() == dest ) {
            // Monster attempts to push player of stairs
            point push( point_north_west );
            int tries = 0;
 
            // the critter is now right on top of you and will attack unless
            // it can find a square to push you into with one of his tries.
            const int creature_push_attempts = 9;
            const int player_throw_resist_chance = 3;
 
            critter.spawn( dest );
            while( tries < creature_push_attempts ) {
                tries++;
                push.x = rng( -1, 1 );
                push.y = rng( -1, 1 );
                point ipos( mpos + push );
                tripoint pos( ipos, get_levz() );
                if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
                    critter.can_move_to( pos ) ) {
                    bool resiststhrow = ( u.is_throw_immune() ) ||
                                        ( u.has_trait( trait_LEG_TENT_BRACE ) );
                    if( resiststhrow && one_in( player_throw_resist_chance ) ) {
                        u.moves -= 25; // small charge for avoiding the push altogether
                        add_msg( _( "The %s fails to push you back!" ),
                                 critter.name() );
                        return; //judo or leg brace prevent you from getting pushed at all
                    }
                    // Not accounting for tentacles latching on, so..
                    // Something is about to happen, lets charge half a move
                    u.moves -= 50;
                    if( resiststhrow && ( u.is_throw_immune() ) ) {
                        //we have a judoka who isn't getting pushed but counterattacking now.
                        mattack::thrown_by_judo( &critter );
                        return;
                    }
                    std::string msg;
                    ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
                    if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
                        // dodge 12 - never get downed
                        // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
                        u.add_effect( effect_downed, 2_turns );
                        msg = _( "The %s pushed you back hard!" );
                    } else {
                        msg = _( "The %s pushed you back!" );
                    }
                    add_msg( m_warning, msg.c_str(), critter.name() );
                    u.setx( u.posx() + push.x );
                    u.sety( u.posy() + push.y );
                    return;
                }
            }
            add_msg( m_warning,
                     _( "The %s tried to push you back but failed!  It attacks you!" ),
                     critter.name() );
            critter.melee_attack( u );
            u.moves -= 50;
            return;
        } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
            // Monster attempts to displace a monster from the stairs
            monster &other = *mon_ptr;
            critter.spawn( dest );
 
            // the critter is now right on top of another and will push it
            // if it can find a square to push it into inside of his tries.
            const int creature_push_attempts = 9;
            const int creature_throw_resist = 4;
 
            int tries = 0;
            point push2;
            while( tries < creature_push_attempts ) {
                tries++;
                push2.x = rng( -1, 1 );
                push2.y = rng( -1, 1 );
                point ipos2( mpos + push2 );
                tripoint pos( ipos2, get_levz() );
                if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
                    continue;
                }
                if( !critter_at( pos ) && other.can_move_to( pos ) ) {
                    other.setpos( tripoint( ipos2, get_levz() ) );
                    other.moves -= 50;
                    std::string msg;
                    if( one_in( creature_throw_resist ) ) {
                        other.add_effect( effect_downed, 2_turns );
                        msg = _( "The %1$s pushed the %2$s hard." );
                    } else {
                        msg = _( "The %1$s pushed the %2$s." );
                    }
                    add_msg( m_neutral, msg, critter.name(), other.name() );
                    return;
                }
            }
            return;
        }
    }
}

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

update_zombie_pos()

bool game::update_zombie_pos	(	const monster &	critter,
		const tripoint &	pos
	)

Redirects to the creature_tracker update_pos() function.

Definition at line 5017 of file game.cpp.

{
    return critter_tracker->update_pos( critter, pos );
}

References critter_tracker.

use_computer()

void game::use_computer

(

const tripoint &

p

)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4800 of file game.cpp.

{
    if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
        add_msg( m_info, _( "You can not read a computer screen!" ) );
        return;
    }
    if( u.is_blind() ) {
        // we don't have screen readers in game
        add_msg( m_info, _( "You can not see a computer screen!" ) );
        return;
    }
    if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
        !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
        add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
        return;
    }
 
    computer *used = m.computer_at( p );
 
    if( used == nullptr ) {
        if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
            add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
        } else {
            debugmsg( "Tried to use computer at %s - none there", p.to_string() );
        }
        return;
    }
 
    computer_session( *used ).use();
}

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

validate_camps()

void game::validate_camps

(

)

validate camps to ensure they are on the overmap list

Definition at line 2034 of file game.cpp.

{
    basecamp camp = m.hoist_submap_camp( u.pos() );
    if( camp.is_valid() ) {
        overmap_buffer.add_camp( camp );
        m.remove_submap_camp( u.pos() );
    } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
        std::string camp_name = _( "Faction Camp" );
        camp.set_name( camp_name );
        overmap_buffer.add_camp( camp );
        m.remove_submap_camp( u.pos() );
    }
}

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

validate_linked_vehicles()

void game::validate_linked_vehicles

(

)

validate towed vehicles so they get linked up again after a load

Definition at line 1976 of file game.cpp.

{
    for( auto &veh : m.get_vehicles() ) {
        vehicle *v = veh.v;
        if( v->tow_data.other_towing_point != tripoint_zero ) {
            vehicle *other_v = veh_pointer_or_null( m.veh_at( v->tow_data.other_towing_point ) );
            if( other_v ) {
                // the other vehicle is towing us.
                v->tow_data.set_towing( other_v, v );
                v->tow_data.other_towing_point = tripoint_zero;
            }
        }
    }
}

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

validate_mounted_npcs()

void game::validate_mounted_npcs

(

)

Definition at line 1991 of file game.cpp.

{
    for( monster &m : all_monsters() ) {
        if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
            player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
            if( !mounted_pl ) {
                // Target no longer valid.
                m.mounted_player_id = character_id();
                m.remove_effect( effect_ridden );
                continue;
            }
            mounted_pl->mounted_creature = shared_from( m );
            mounted_pl->setpos( m.pos() );
            mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
            m.mounted_player = mounted_pl;
        }
    }
}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

validate_npc_followers()

void game::validate_npc_followers

(

)

validate list of followers to account for overmap buffers

Definition at line 2010 of file game.cpp.

{
    // Make sure visible followers are in the list.
    const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
        return guy.is_player_ally();
    } );
    for( npc *guy : visible_followers ) {
        update_faction_api( guy );
        add_npc_follower( guy->getID() );
    }
    // Make sure overmapbuffered NPC followers are in the list.
    for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
        npc *guy = temp_guy.get();
        if( guy->is_player_ally() ) {
            update_faction_api( guy );
            add_npc_follower( guy->getID() );
        }
    }
    // Make sure that serialized player followers sync up with game list
    for( const auto &temp_id : u.follower_ids ) {
        add_npc_follower( temp_id );
    }
}

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

vertical_move()

void game::vertical_move	(	int	z,
		bool	force,
		bool	peeking = false
	)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10497 of file game.cpp.

{
    if( u.is_mounted() ) {
        auto mons = u.mounted_creature.get();
        if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
            if( !mons->check_mech_powered() ) {
                add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
                         mons->get_name() );
                return;
            }
        }
    }
 
    // > and < are used for diving underwater.
    if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
        if( movez == -1 ) {
            if( u.is_underwater() ) {
                add_msg( m_info, _( "You are already underwater!" ) );
                return;
            }
            if( u.worn_with_flag( "FLOTATION" ) ) {
                add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
                return;
            }
            u.set_underwater( true );
            ///\EFFECT_STR increases breath-holding capacity while diving
            u.oxygen = 30 + 2 * u.str_cur;
            add_msg( _( "You dive underwater!" ) );
        } else {
            if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
                u.set_underwater( false );
                add_msg( _( "You surface." ) );
            } else {
                add_msg( m_info, _( "You try to surface but can't!" ) );
            }
        }
        u.moves -= 100;
        return;
    }
 
    // Force means we're going down, even if there's no staircase, etc.
    bool climbing = false;
    int move_cost = 100;
    tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
    if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
        // Climbing
        if( m.has_floor_or_support( stairs ) ) {
            add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
            return;
        }
 
        std::vector<tripoint> pts;
        for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
            if( m.passable( pt ) &&
                m.has_floor_or_support( pt ) ) {
                pts.push_back( pt );
            }
        }
 
        const int cost = u.climbing_cost( u.pos(), stairs );
 
        if( cost == 0 ) {
            if( u.has_trait( trait_WEB_ROPE ) )  {
                if( pts.empty() ) {
                    add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
                } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
                    if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
                        add_msg( m_info, _( "You can't spin a web rope there." ) );
                    } else if( g->m.has_furn( u.pos() ) ) {
                        add_msg( m_info, _( "There is already furniture at that location." ) );
                    } else {
                        if( query_yn( "Spin a rope and climb?" ) ) {
                            add_msg( m_good, _( "You spin a rope of web." ) );
                            g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
                            u.mod_moves( to_turns<int>( 2_seconds ) );
                            u.mutation_spend_resources( trait_WEB_ROPE );
                            vertical_move( movez, force, peeking );
                        }
                    }
                }
 
            } else {
                add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
 
            }
            return;
 
        }
 
        if( cost <= 0 || pts.empty() ) {
            add_msg( m_info,
                     _( "You can't climb here - there is no terrain above you that would support your weight." ) );
            return;
        } else {
            // TODO: Make it an extended action
            climbing = true;
            move_cost = cost;
 
            const cata::optional<tripoint> pnt = point_selection_menu( pts );
            if( !pnt ) {
                return;
            }
            stairs = *pnt;
        }
    }
 
    if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
        add_msg( m_info, _( "You can't go down here!" ) );
        return;
    } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
        add_msg( m_info, _( "You can't go up here!" ) );
        return;
    }
 
    if( force ) {
        // Let go of a grabbed cart.
        u.grab( OBJECT_NONE );
    } else if( u.grab_point != tripoint_zero ) {
        add_msg( m_info, _( "You can't drag things up and down stairs." ) );
        return;
    }
 
    // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
    // is called or when the map is loaded on new z-level (== false).
    // This caches the z-level we start the movement on (current) and the level we're want to end.
    const int z_before = get_levz();
    const int z_after = get_levz() + movez;
    if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
        debugmsg( "Tried to move outside allowed range of z-levels" );
        return;
    }
 
    if( !u.move_effects( false ) ) {
        return;
    }
 
    // Check if there are monsters are using the stairs.
    bool slippedpast = false;
    if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
        // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
        add_msg( m_warning, _( "You try to use the stairs.  Suddenly you are blocked by a %s!" ),
                 coming_to_stairs[0].name() );
        // Roll.
        ///\EFFECT_DEX increases chance of moving past monsters on stairs
 
        ///\EFFECT_DODGE increases chance of moving past monsters on stairs
        int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
        ///\EFFECT_STR increases chance of moving past monsters on stairs
 
        ///\EFFECT_MELEE increases chance of moving past monsters on stairs
        int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
        if( coming_to_stairs.size() > 4 ) {
            add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
            dexroll /= 4;
            strroll /= 2;
        } else if( coming_to_stairs.size() > 1 ) {
            add_msg( m_warning, _( "There's something else behind it!" ) );
            dexroll /= 2;
        }
 
        if( dexroll < 14 || strroll < 12 ) {
            update_stair_monsters();
            u.moves -= 100;
            return;
        }
 
        add_msg( _( "You manage to slip past!" ) );
        slippedpast = true;
        u.moves -= 100;
    }
 
    // Shift the map up or down
 
    std::unique_ptr<map> tmp_map_ptr;
    if( !m.has_zlevels() ) {
        tmp_map_ptr = std::make_unique<map>();
    }
 
    map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
    if( m.has_zlevels() ) {
        // We no longer need to shift the map here! What joy
    } else {
        maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
    }
 
    // Find the corresponding staircase
    bool rope_ladder = false;
    // TODO: Remove the stairfinding, make the mapgen gen aligned maps
    if( !force && !climbing ) {
        const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
        if( !pnt ) {
            return;
        }
        stairs = *pnt;
    }
 
    if( !force ) {
        monstairz = z_before;
    }
    // Save all monsters that can reach the stairs, remove them from the tracker,
    // then despawn the remaining monsters. Because it's a vertical shift, all
    // monsters are out of the bounds of the map and will despawn.
    shared_ptr_fast<monster> stored_mount;
    if( u.is_mounted() && !m.has_zlevels() ) {
        // Store a *copy* of the mount, so we can remove the original monster instance
        // from the tracker before the map shifts.
        // Map shifting would otherwise just despawn the mount and would later respawn it.
        stored_mount = make_shared_fast<monster>( *u.mounted_creature );
        critter_tracker->remove( *u.mounted_creature );
    }
    if( !m.has_zlevels() ) {
        const tripoint to = u.pos();
        for( monster &critter : all_monsters() ) {
            // if its a ladder instead of stairs - most zombies can't climb that.
            // unless that have a special flag to allow them to do so.
            if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
                critter.has_effect( effect_ridden ) ||
                critter.has_effect( effect_tied ) ) {
                continue;
            }
            int turns = critter.turns_to_reach( to.xy() );
            if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
                && !slippedpast ) {
                critter.staircount = 10 + turns;
                critter.on_unload();
                coming_to_stairs.push_back( critter );
                remove_zombie( critter );
            }
        }
        auto mons = critter_tracker->find( g->u.pos() );
        if( mons != nullptr ) {
            critter_tracker->remove( *mons );
        }
        shift_monsters( tripoint( 0, 0, movez ) );
    }
 
    std::vector<shared_ptr_fast<npc>> npcs_to_bring;
    std::vector<monster *> monsters_following;
    if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
        std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
        [this]( const shared_ptr_fast<npc> &np ) {
            return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
                   rl_dist( np->pos(), u.pos() ) < 2;
        } );
    }
 
    if( m.has_zlevels() && std::abs( movez ) == 1 ) {
        bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
        for( monster &critter : all_monsters() ) {
            if( ladder && !critter.climbs() ) {
                continue;
            }
            if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
                    critter.has_effect( effect_pet ) && critter.friendly == -1 &&
                    !critter.has_effect( effect_tied ) ) ) {
                monsters_following.push_back( &critter );
            }
        }
    }
 
    if( u.is_mounted() ) {
        monster *crit = u.mounted_creature.get();
        if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
            crit->use_mech_power( -1 );
            if( u.movement_mode_is( CMM_WALK ) ) {
                crit->use_mech_power( -2 );
            } else if( u.movement_mode_is( CMM_CROUCH ) ) {
                crit->use_mech_power( -1 );
            } else if( u.movement_mode_is( CMM_RUN ) ) {
                crit->use_mech_power( -3 );
            }
        }
    } else {
        u.moves -= move_cost;
    }
    for( const auto &np : npcs_to_bring ) {
        if( np->in_vehicle ) {
            g->m.unboard_vehicle( np->pos() );
        }
    }
    const tripoint old_pos = g->u.pos();
    point submap_shift;
    vertical_shift( z_after );
    if( !force ) {
        submap_shift = update_map( stairs.x, stairs.y );
    }
 
    // if an NPC or monster is on the stiars when player ascends/descends
    // they may end up merged on th esame tile, do some displacement to resolve that.
    // if, in the weird case of it not being possible to displace;
    // ( how did the player even manage to approach the stairs, if so? )
    // then nothing terrible happens, its just weird.
    if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
        std::string crit_name;
        bool player_displace = false;
        cata::optional<tripoint> displace = find_empty_spot_nearby( u.pos() );
        if( displace.has_value() ) {
            npc *guy = g->critter_at<npc>( u.pos(), true );
            if( guy ) {
                crit_name = guy->get_name();
                tripoint old_pos = guy->pos();
                if( !guy->is_enemy() ) {
                    guy->move_away_from( u.pos(), true );
                    if( old_pos != guy->pos() ) {
                        add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
                    }
                } else {
                    player_displace = true;
                }
            }
            monster *mon = g->critter_at<monster>( u.pos(), true );
            // if the monster is ridden by the player or an NPC:
            // Dont displace them. If they are mounted by a friendly NPC,
            // then the NPC will already have been displaced just above.
            // if they are ridden by the player, we want them to coexist on same tile
            if( mon && !mon->mounted_player ) {
                crit_name = mon->get_name();
                if( mon->friendly == -1 ) {
                    mon->setpos( *displace );
                    add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
                } else {
                    player_displace = true;
                }
            }
            if( player_displace ) {
                u.setpos( *displace );
                u.moves -= 20;
                add_msg( _( "You push past %s blocking the way." ), crit_name );
            }
        } else {
            debugmsg( "Failed to find a spot to displace into." );
        }
    }
 
    // Now that we know the player's destination position, we can move their mount as well
    if( u.is_mounted() ) {
        if( stored_mount ) {
            assert( !m.has_zlevels() );
            stored_mount->spawn( g->u.pos() );
            if( critter_tracker->add( stored_mount ) ) {
                u.mounted_creature = stored_mount;
            }
        } else {
            u.mounted_creature->setpos( g->u.pos() );
        }
    }
 
    if( !npcs_to_bring.empty() ) {
        // Would look nicer randomly scrambled
        std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
        candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
        [this]( const tripoint & c ) {
            return !is_empty( c );
        } ), candidates.end() );
 
        for( const auto &np : npcs_to_bring ) {
            const auto found = std::find_if( candidates.begin(), candidates.end(),
            [this, np]( const tripoint & c ) {
                return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
            } );
            if( found != candidates.end() ) {
                // TODO: De-uglify
                np->setpos( *found );
                np->place_on_map();
                np->setpos( *found );
                candidates.erase( found );
            }
 
            if( candidates.empty() ) {
                break;
            }
        }
 
        reload_npcs();
    }
 
    // This ugly check is here because of stair teleport bullshit
    // TODO: Remove stair teleport bullshit
    if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
        for( monster *m : monsters_following ) {
            m->set_dest( g->u.pos() );
        }
    }
 
    if( rope_ladder ) {
        m.ter_set( u.pos(), t_rope_up );
    }
 
    if( m.ter( stairs ) == t_manhole_cover ) {
        m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
        m.ter_set( stairs, t_manhole );
    }
 
    // Wouldn't work and may do strange things
    if( u.is_hauling() && !m.has_zlevels() ) {
        add_msg( _( "You cannot haul items here." ) );
        u.stop_hauling();
    }
 
    if( u.is_hauling() ) {
        const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
        start_hauling( adjusted_pos );
    }
 
    m.invalidate_map_cache( g->get_levz() );
    // Upon force movement, traps can not be avoided.
    m.creature_on_trap( u, !force );
 
    cata_event_dispatch::avatar_moves( u, m, u.pos() );
}

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), player::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

vertical_notes()

void game::vertical_notes	(	int	z_before,
		int	z_after
	)

Add goes up/down auto_notes (if turned on)

Definition at line 11130 of file game.cpp.

{
    if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
        !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
        return;
    }
 
    if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
        debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
                  z_before, z_after );
        return;
    }
    // Figure out where we know there are up/down connectors
    // Fill in all the tiles we know about (e.g. subway stations)
    static const int REVEAL_RADIUS = 40;
    for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
        const tripoint_abs_omt cursp_before( p.xy(), z_before );
        const tripoint_abs_omt cursp_after( p.xy(), z_after );
 
        if( !overmap_buffer.seen( cursp_before ) ) {
            continue;
        }
        if( overmap_buffer.has_note( cursp_after ) ) {
            // Already has a note -> never add an AUTO-note
            continue;
        }
        const oter_id &ter = overmap_buffer.ter( cursp_before );
        const oter_id &ter2 = overmap_buffer.ter( cursp_after );
        if( z_after > z_before && ter->has_flag( known_up ) &&
            !ter2->has_flag( known_down ) ) {
            overmap_buffer.set_seen( cursp_after, true );
            overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
        } else if( z_after < z_before && ter->has_flag( known_down ) &&
                   !ter2->has_flag( known_up ) ) {
            overmap_buffer.set_seen( cursp_after, true );
            overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
        }
    }
}

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

vertical_shift()

void game::vertical_shift

(

int

z_after

)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 11093 of file game.cpp.

{
    if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
        debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
                  z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
        return;
    }
 
    // TODO: Implement dragging stuff up/down
    u.grab( OBJECT_NONE );
 
    scent.reset();
 
    u.setz( z_after );
    const int z_before = get_levz();
    if( !m.has_zlevels() ) {
        m.clear_vehicle_cache( z_before );
        m.access_cache( z_before ).vehicle_list.clear();
        m.access_cache( z_before ).zone_vehicles.clear();
        m.access_cache( z_before ).map_memory_seen_cache.reset();
        m.set_transparency_cache_dirty( z_before );
        m.set_outside_cache_dirty( z_before );
        m.load( tripoint( get_levx(), get_levy(), z_after ), true );
        shift_monsters( tripoint( 0, 0, z_after - z_before ) );
        reload_npcs();
    } else {
        // Shift the map itself
        m.vertical_shift( z_after );
    }
 
    m.spawn_monsters( true );
    // this may be required after a vertical shift if z-levels are not enabled
    // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
    validate_mounted_npcs();
    vertical_notes( z_before, z_after );
}

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

walk_move()

bool game::walk_move	(	const tripoint &	dest,
		bool	via_ramp = false
	)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 9312 of file game.cpp.

{
    if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
        if( u.get_size() > MS_MEDIUM ) {
            add_msg( m_warning, _( "You can't fit there." ) );
            return false; // character too large to fit through a tight passage
        }
        if( u.is_mounted() ) {
            monster *mount = u.mounted_creature.get();
            if( mount->get_size() > MS_MEDIUM ) {
                add_msg( m_warning, _( "Your mount can't fit there." ) );
                return false; // char's mount is too large for tight passages
            }
        }
    }
 
    if( u.is_mounted() ) {
        auto mons = u.mounted_creature.get();
        if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
            if( !mons->check_mech_powered() ) {
                add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
                         mons->get_name() );
                return false;
            }
        }
        if( !mons->move_effects( false ) ) {
            add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
            return false;
        }
    }
    const optional_vpart_position vp_here = m.veh_at( u.pos() );
    const optional_vpart_position vp_there = m.veh_at( dest_loc );
 
    bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
    bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
    bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
 
    const tripoint furn_pos = u.pos() + u.grab_point;
    const tripoint furn_dest = dest_loc + u.grab_point;
 
    bool grabbed = u.get_grab_type() != OBJECT_NONE;
    if( grabbed ) {
        const tripoint dp = dest_loc - u.pos();
        pushing = dp ==  u.grab_point;
        pulling = dp == -u.grab_point;
    }
    if( grabbed && dest_loc.z != u.posz() ) {
        add_msg( m_warning, _( "You let go of the grabbed object." ) );
        grabbed = false;
        u.grab( OBJECT_NONE );
    }
 
    // Now make sure we're actually holding something
    const vehicle *grabbed_vehicle = nullptr;
    if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
        // We only care about shifting, because it's the only one that can change our destination
        if( m.has_furn( u.pos() + u.grab_point ) ) {
            shifting_furniture = !pushing && !pulling;
        } else {
            // We were grabbing a furniture that isn't there
            grabbed = false;
        }
    } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
        grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
        if( grabbed_vehicle == nullptr ) {
            // We were grabbing a vehicle that isn't there anymore
            grabbed = false;
        }
    } else if( grabbed ) {
        // We were grabbing something WEIRD, let's pretend we weren't
        grabbed = false;
    }
    if( u.grab_point != tripoint_zero && !grabbed ) {
        add_msg( m_warning, _( "Can't find grabbed object." ) );
        u.grab( OBJECT_NONE );
    }
 
    if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
        if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
            vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
            tripoint diff = dest_loc - u.pos();
            if( diff.x < 0 ) {
                diff.x -= 2;
            } else if( diff.x > 0 ) {
                diff.x += 2;
            }
            if( diff.y < 0 ) {
                diff.y -= 2;
            } else if( diff.y > 0 ) {
                diff.y += 2;
            }
            u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
                                               dest_loc );
        }
        return false;
    }
    if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
        return false;
    }
    if( u.is_mounted() && !pushing && vp_there ) {
        add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
        return false;
    }
    u.set_underwater( false );
 
    if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
        std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
        if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
            !prompt_dangerous_tile( dest_loc ) ) {
            return true;
        } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
                   ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
            add_msg( m_warning,
                     _( "Stepping into that %1$s looks risky.  Run into it if you wish to enter anyway." ),
                     enumerate_as_string( harmful_stuff ) );
            return true;
        } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
                   ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
            add_msg( m_warning,
                     _( "Stepping into that %1$s looks risky.  Crouch and move into it if you wish to enter anyway." ),
                     enumerate_as_string( harmful_stuff ) );
            return true;
        } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
                   !u.movement_mode_is( CMM_RUN ) ) {
            add_msg( m_warning,
                     _( "Stepping into that %1$s looks risky.  Run into it if you wish to enter anyway." ),
                     enumerate_as_string( harmful_stuff ) );
            return true;
        }
    }
    // Used to decide whether to print a 'moving is slow message
    const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
 
    int modifier = 0;
    if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
        modifier = -m.furn( dest_loc ).obj().movecost;
    }
 
    int multiplier = 1;
    if( u.is_on_ground() ) {
        multiplier *= 3;
    }
 
    const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
                                           via_ramp ) * multiplier;
    if( grabbed_move( dest_loc - u.pos() ) ) {
        return true;
    } else if( mcost == 0 ) {
        return false;
    }
    bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
    const int previous_moves = u.moves;
    if( u.is_mounted() ) {
        auto crit = u.mounted_creature.get();
        if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
            ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
              m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
              m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
              m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
              m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
            add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
            return false;
        }
        const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
        const double encumb_moves = u.get_weight() / 4800.0_gram;
        u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
        if( u.movement_mode_is( CMM_WALK ) ) {
            crit->use_mech_power( -2 );
        } else if( u.movement_mode_is( CMM_CROUCH ) ) {
            crit->use_mech_power( -1 );
        } else if( u.movement_mode_is( CMM_RUN ) ) {
            crit->use_mech_power( -3 );
        }
    } else {
        u.moves -= u.run_cost( mcost, diag );
        /**
        TODO:
        This should really use the mounted creatures stamina, if mounted.
        Monsters don't currently have stamina however.
        For the time being just don't burn players stamina when mounted.
        */
        if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
            //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
            u.burn_move_stamina( previous_moves - u.moves );
        } else {
            //Burn half as much stamina if vehicle has wheels, without changing move time
            u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
        }
    }
    // Max out recoil & reset aim point
    u.recoil = MAX_RECOIL;
    u.last_target_pos = cata::nullopt;
 
    // Print a message if movement is slow
    const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
    const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
                        m.has_flag_ter_or_furn( "FUNGUS",
                                dest_loc ); //fungal furniture has no slowing effect on mycus characters
    const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
                          mcost_to > 4 || mcost_from > 4 ) &&
                        !( u.has_trait( trait_M_IMMUNE ) && fungus );
    if( slowed && !u.is_mounted() ) {
        // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
        if( mcost_to >= mcost_from ) {
            if( auto displayed_part = vp_there.part_displayed() ) {
                add_msg( m_warning, _( "Moving onto this %s is slow!" ),
                         displayed_part->part().name() );
                sfx::do_obstacle( displayed_part->part().info().get_id().str() );
            } else {
                add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
                sfx::do_obstacle( m.ter( dest_loc ).id().str() );
            }
        } else {
            if( auto displayed_part = vp_here.part_displayed() ) {
                add_msg( m_warning, _( "Moving off of this %s is slow!" ),
                         displayed_part->part().name() );
                sfx::do_obstacle( displayed_part->part().info().get_id().str() );
            } else {
                add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
                sfx::do_obstacle( m.ter( u.pos() ).id().str() );
            }
        }
    }
    if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
        ( !u.footwear_factor() ||
          ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
        // DX and IN are long suits for Cephalopods,
        // so this shouldn't cause too much hardship
        // Presumed that if it's swimmable, they're
        // swimming and won't stick
        ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
 
        ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
        if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
            add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
            u.mod_fatigue( 1 );
        }
    }
    if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
        int volume = u.is_stealthy() ? 3 : 6;
        volume *= u.mutation_value( "noise_modifier" );
        if( volume > 0 ) {
            if( u.is_wearing( itype_rm13_armor_on ) ) {
                volume = 2;
            } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
                volume = 12;
            }
            if( u.movement_mode_is( CMM_RUN ) ) {
                volume *= 1.5;
            } else if( u.movement_mode_is( CMM_CROUCH ) ) {
                volume /= 2;
            }
            if( u.is_mounted() ) {
                auto mons = u.mounted_creature.get();
                switch( mons->get_size() ) {
                    case MS_TINY:
                        volume = 0; // No sound for the tinies
                        break;
                    case MS_SMALL:
                        volume /= 3;
                        break;
                    case MS_MEDIUM:
                        break;
                    case MS_LARGE:
                        volume *= 1.5;
                        break;
                    case MS_HUGE:
                        volume *= 2;
                        break;
                    default:
                        break;
                }
                if( mons->has_flag( MF_LOUDMOVES ) ) {
                    volume += 6;
                }
                sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
                               "none", "none" );
            } else {
                sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
                               "none", "none" );    // Sound of footsteps may awaken nearby monsters
            }
            sfx::do_footstep();
        }
 
        if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
            sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
                           "misc", "rattling" );
        }
    }
 
    if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
        add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
    }
 
    if( dest_loc != u.pos() ) {
        cata_event_dispatch::avatar_moves( u, m, dest_loc );
    }
 
    tripoint oldpos = u.pos();
    point submap_shift = place_player( dest_loc );
    point ms_shift = sm_to_ms_copy( submap_shift );
    oldpos = oldpos - ms_shift;
 
    if( pulling ) {
        const tripoint shifted_furn_pos = furn_pos - ms_shift;
        const tripoint shifted_furn_dest = furn_dest - ms_shift;
        const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
        const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
        m.remove_field( shifted_furn_pos, fd_fire );
        m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
        m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
    }
 
    if( u.is_hauling() ) {
        start_hauling( oldpos );
    }
 
    on_move_effects();
 
    return true;
}

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

wield() [1/2]

void game::wield ( )

private

Definition at line 9101 of file game.cpp.

{
    item_location loc = game_menus::inv::wield( u );
 
    if( loc ) {
        wield( loc );
    } else {
        add_msg( _( "Never mind." ) );
    }
}

References _, add_msg(), u, wield(), and game_menus::inv::wield().

Referenced by handle_action(), inventory_item_menu(), and wield().

wield() [2/2]

void game::wield ( item_location &  loc )

private

Definition at line 9013 of file game.cpp.

{
    if( u.is_armed() ) {
        const bool is_unwielding = u.is_wielding( *loc );
        const auto ret = u.can_unwield( *loc );
 
        if( !ret.success() ) {
            add_msg( m_info, "%s", ret.c_str() );
        }
 
        u.unwield();
 
        if( is_unwielding ) {
            if( !u.martial_arts_data->selected_is_none() ) {
                u.martial_arts_data->martialart_use_message( u );
            }
            return;
        }
    }
 
    const auto ret = u.can_wield( *loc );
    if( !ret.success() ) {
        add_msg( m_info, "%s", ret.c_str() );
    }
 
    // Need to do this here because holster_actor::use() checks if/where the item is worn
    item &target = *loc.get_item();
    if( target.get_use( "holster" ) && !target.contents.empty() ) {
        //~ %1$s: weapon name, %2$s: holster name
        if( query_yn( pgettext( "holster", "Draw %1$s from %2$s?" ), target.get_contained().tname(),
                      target.tname() ) ) {
            u.invoke_item( &target );
            return;
        }
    }
 
    // Can't use loc.obtain() here because that would cause things to spill.
    item to_wield = *loc.get_item();
    item_location::type location_type = loc.where();
    tripoint pos = loc.position();
    int worn_index = INT_MIN;
    if( u.is_worn( *loc.get_item() ) ) {
        auto ret = u.can_takeoff( *loc.get_item() );
        if( !ret.success() ) {
            add_msg( m_info, "%s", ret.c_str() );
            return;
        }
        int item_pos = u.get_item_position( loc.get_item() );
        if( item_pos != INT_MIN ) {
            worn_index = Character::worn_position_to_index( item_pos );
        }
    }
    loc.remove_item();
    if( !u.wield( to_wield ) ) {
        switch( location_type ) {
            case item_location::type::container:
                // this will not cause things to spill, as it is inside another item
                loc = loc.obtain( g->u );
                wield( loc );
                break;
            case item_location::type::character:
                if( worn_index != INT_MIN ) {
                    auto it = u.worn.begin();
                    std::advance( it, worn_index );
                    u.worn.insert( it, to_wield );
                } else {
                    u.i_add( to_wield );
                }
                break;
            case item_location::type::map:
                m.add_item( pos, to_wield );
                break;
            case item_location::type::vehicle: {
                const cata::optional<vpart_reference> vp = g->m.veh_at( pos ).part_with_feature( "CARGO", false );
                // If we fail to return the item to the vehicle for some reason, add it to the map instead.
                if( !vp || !( vp->vehicle().add_item( vp->part_index(), to_wield ) ) ) {
                    m.add_item( pos, to_wield );
                }
                break;
            }
            case item_location::type::invalid:
                debugmsg( "Failed wield from invalid item location" );
                break;
        }
        return;
    }
}

References map::add_item(), add_msg(), player::can_takeoff(), Character::can_unwield(), player::can_wield(), item_location::character, item_location::container, item::contents, debugmsg, item_contents::empty(), g, item::get_contained(), item_location::get_item(), Character::get_item_position(), item::get_use(), Character::i_add(), item_location::invalid, avatar::invoke_item(), Character::is_armed(), Character::is_wielding(), Character::is_worn(), m, m_info, item_location::map, Character::martial_arts_data, item_location::obtain(), pgettext(), item_location::position(), query_yn(), item_location::remove_item(), cata::hash64_detail::ret, item::tname(), u, player::unwield(), item_location::vehicle, item_location::where(), wield(), avatar::wield(), Character::worn, and Character::worn_position_to_index().

win()

void game::win

(

)

Marks the game as won.

Doesn't end the game.

Definition at line 2732 of file game.cpp.

{
    win_screen();
    const time_duration game_duration = calendar::turn - calendar::start_of_game;
    memorial().add(
        pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
        pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
        to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
    if( !u.is_dead_state() ) {
        Messages::display_messages();
        show_scores_ui( *achievements_tracker_ptr, stats(), get_kill_tracker() );
    }
}

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

win_screen()

void game::win_screen ( )

private

Definition at line 2746 of file game.cpp.

{
    // TODO: Move this wall somewhere
    const time_duration game_duration = calendar::turn - calendar::start_of_game;
    std::string msg = _( "You managed to close the portal and end the invasion!" );
    msg += '\n';
    if( u.is_dead_state() ) {
        translation t = translation::to_translation( "win_game",
                        "Unfortunately, you had to sacrifice your life to achieve this." );
        msg += colorize( t, c_red ) + '\n';
        memorial().add(
            pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
            pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
    } else {
        translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
        msg += colorize( t, c_green ) + '\n';
        memorial().add(
            pgettext( "memorial_male", "Safely closed the portal." ),
            pgettext( "memorial_female", "Safely closed the portal." ) );
    }
    msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
                          to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
    // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
    popup( msg );
}

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

write_memorial_file()

void game::write_memorial_file	(	const std::string &	filename,
		std::string	sLastWords
	)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 3135 of file game.cpp.

{
    const std::string &memorial_dir = PATH_INFO::memorialdir();
    const std::string &memorial_active_world_dir = memorial_dir +
            world_generator->active_world->world_name + "/";
 
    //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
    if( !assure_dir_exist( memorial_dir ) ) {
        debugmsg( "Could not make '%s' directory", memorial_dir );
        return;
    }
 
    if( !assure_dir_exist( memorial_active_world_dir ) ) {
        debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
        return;
    }
 
    std::string path = memorial_active_world_dir + filename + ".txt";
 
    write_to_file( path, [&]( std::ostream & fout ) {
        memorial().write( fout, sLastWords );
    }, _( "player memorial" ) );
}

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

zones_manager()

void game::zones_manager

(

)

Definition at line 6360 of file game.cpp.

{
    const tripoint stored_view_offset = u.view_offset;
 
    u.view_offset = tripoint_zero;
 
    const int zone_ui_height = 12;
    const int zone_options_height = 7;
 
    const int width = 45;
 
    int offsetX = 0;
    int max_rows = 0;
 
    catacurses::window w_zones;
    catacurses::window w_zones_border;
    catacurses::window w_zones_info;
    catacurses::window w_zones_info_border;
    catacurses::window w_zones_options;
 
    bool show = true;
 
    ui_adaptor ui;
    ui.on_screen_resize( [&]( ui_adaptor & ui ) {
        if( !show ) {
            ui.position( point_zero, point_zero );
            return;
        }
        offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
                  TERMX - width : 0;
        const int w_zone_height = TERMY - zone_ui_height;
        max_rows = w_zone_height - 2;
        w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
                                      point( offsetX + 1, 1 ) );
        w_zones_border = catacurses::newwin( w_zone_height, width,
                                             point( offsetX, 0 ) );
        w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
                                           width - 2, point( offsetX + 1, w_zone_height ) );
        w_zones_info_border = catacurses::newwin( zone_ui_height, width,
                              point( offsetX, w_zone_height ) );
        w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
                                              point( offsetX + 1, TERMY - zone_options_height ) );
 
        ui.position( point( offsetX, 0 ), point( width, TERMY ) );
    } );
    ui.mark_resize();
 
    std::string action;
    input_context ctxt( "ZONES_MANAGER" );
    ctxt.register_cardinal();
    ctxt.register_action( "CONFIRM" );
    ctxt.register_action( "QUIT" );
    ctxt.register_action( "ADD_ZONE" );
    ctxt.register_action( "REMOVE_ZONE" );
    ctxt.register_action( "MOVE_ZONE_UP" );
    ctxt.register_action( "MOVE_ZONE_DOWN" );
    ctxt.register_action( "SHOW_ZONE_ON_MAP" );
    ctxt.register_action( "ENABLE_ZONE" );
    ctxt.register_action( "DISABLE_ZONE" );
    ctxt.register_action( "SHOW_ALL_ZONES" );
    ctxt.register_action( "HELP_KEYBINDINGS" );
 
    auto &mgr = zone_manager::get_manager();
    int start_index = 0;
    int active_index = 0;
    bool blink = false;
    bool stuff_changed = false;
    bool show_all_zones = false;
    int zone_cnt = 0;
 
    // get zones on the same z-level, with distance between player and
    // zone center point <= 50 or all zones, if show_all_zones is true
    auto get_zones = [&]() {
        std::vector<zone_manager::ref_zone_data> zones;
        if( show_all_zones ) {
            zones = mgr.get_zones();
        } else {
            const tripoint &u_abs_pos = m.getabs( u.pos() );
            for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
                const tripoint &zone_abs_pos = ref.get().get_center_point();
                if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
                    zones.emplace_back( ref );
                }
            }
        }
        zone_cnt = static_cast<int>( zones.size() );
        return zones;
    };
 
    auto zones = get_zones();
 
    auto zones_manager_options = [&]() {
        werase( w_zones_options );
 
        if( zone_cnt > 0 ) {
            const auto &zone = zones[active_index].get();
 
            if( zone.has_options() ) {
                const auto &descriptions = zone.get_options().get_descriptions();
 
                // NOLINTNEXTLINE(cata-use-named-point-constants)
                mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
 
                int y = 1;
                for( const auto &desc : descriptions ) {
                    mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
                    mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
                    y++;
                }
            }
        }
 
        wnoutrefresh( w_zones_options );
    };
 
    cata::optional<tripoint> zone_start;
    cata::optional<tripoint> zone_end;
    bool zone_blink = false;
    bool zone_cursor = false;
    shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback(
                zone_start, zone_end, zone_blink, zone_cursor );
    add_draw_callback( zone_cb );
 
    auto query_position =
    [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
        on_out_of_scope invalidate_current_ui( [&]()
        {
            ui.mark_resize();
        } );
        restore_on_out_of_scope<bool> show_prev( show );
        restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
        restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
        show = false;
        zone_start = cata::nullopt;
        zone_end = cata::nullopt;
        ui.mark_resize();
 
        static_popup popup;
        popup.on_top( true );
        popup.message( "%s", _( "Select first point." ) );
 
        tripoint center = u.pos() + u.view_offset;
 
        const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
                false );
        if( first.position )
        {
            popup.message( "%s", _( "Select second point." ) );
 
            const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
                    true, true, false );
            if( second.position ) {
                tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
                                               second.position->x ),
                                               std::min( first.position->y, second.position->y ),
                                               std::min( first.position->z,
                                                       second.position->z ) ) );
                tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
                                                second.position->x ),
                                                std::max( first.position->y, second.position->y ),
                                                std::max( first.position->z,
                                                        second.position->z ) ) );
                return std::pair<tripoint, tripoint>( first_abs, second_abs );
            }
        }
 
        return cata::nullopt;
    };
 
    ui.on_redraw( [&]( const ui_adaptor & ) {
        if( !show ) {
            return;
        }
        zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
        zones_manager_shortcuts( w_zones_info );
 
        if( zone_cnt == 0 ) {
            werase( w_zones );
            mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
 
        } else {
            werase( w_zones );
 
            calcStartPos( start_index, active_index, max_rows, zone_cnt );
 
            draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
            wnoutrefresh( w_zones_border );
 
            int iNum = 0;
 
            tripoint player_absolute_pos = m.getabs( u.pos() );
 
            //Display saved zones
            for( auto &i : zones ) {
                if( iNum >= start_index &&
                    iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
                    const auto &zone = i.get();
 
                    nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
 
                    if( iNum == active_index ) {
                        mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
                        colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
                    }
 
                    //Draw Zone name
                    mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
                               trim_by_length( zone.get_name(), 15 ) );
 
                    //Draw Type name
                    mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
                               mgr.get_name_from_type( zone.get_type() ) );
 
                    tripoint center = zone.get_center_point();
 
                    //Draw direction + distance
                    mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
                               5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
                               direction_name_short( direction_from( player_absolute_pos,
                                                     center ) ) );
 
                    //Draw Vehicle Indicator
                    mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
                               zone.get_is_vehicle() ? "*" : "" );
                }
                iNum++;
            }
 
            // Display zone options
            zones_manager_options();
        }
 
        wnoutrefresh( w_zones );
    } );
 
    zones_manager_open = true;
    do {
        if( action == "ADD_ZONE" ) {
            do { // not a loop, just for quick bailing out if canceled
                const auto maybe_id = mgr.query_type();
                if( !maybe_id.has_value() ) {
                    break;
                }
 
                const zone_type_id &id = maybe_id.value();
                auto options = zone_options::create( id );
 
                if( !options->query_at_creation() ) {
                    break;
                }
 
                auto default_name = options->get_zone_name_suggestion();
                if( default_name.empty() ) {
                    default_name = mgr.get_name_from_type( id );
                }
                const auto maybe_name = mgr.query_name( default_name );
                if( !maybe_name.has_value() ) {
                    break;
                }
                const std::string &name = maybe_name.value();
 
                const auto position = query_position();
                if( !position ) {
                    break;
                }
 
                mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
                         position->second, options );
 
                zones = get_zones();
                active_index = zone_cnt - 1;
 
                stuff_changed = true;
            } while( false );
 
            blink = false;
        } else if( action == "SHOW_ALL_ZONES" ) {
            show_all_zones = !show_all_zones;
            zones = get_zones();
            active_index = 0;
        } else if( zone_cnt > 0 ) {
            if( action == "UP" ) {
                active_index--;
                if( active_index < 0 ) {
                    active_index = zone_cnt - 1;
                }
                blink = false;
            } else if( action == "DOWN" ) {
                active_index++;
                if( active_index >= zone_cnt ) {
                    active_index = 0;
                }
                blink = false;
            } else if( action == "REMOVE_ZONE" ) {
                if( active_index < zone_cnt ) {
                    mgr.remove( zones[active_index] );
                    zones = get_zones();
                    active_index--;
 
                    if( active_index < 0 ) {
                        active_index = 0;
                    }
                }
                blink = false;
                stuff_changed = true;
 
            } else if( action == "CONFIRM" ) {
                auto &zone = zones[active_index].get();
 
                uilist as_m;
                as_m.text = _( "What do you want to change:" );
                as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
                as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
                as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
                                           zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
                as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
                // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
                as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
                as_m.query();
 
                switch( as_m.ret ) {
                    case 1:
                        if( zone.set_name() ) {
                            stuff_changed = true;
                        }
                        break;
                    case 2:
                        if( zone.set_type() ) {
                            stuff_changed = true;
                        }
                        break;
                    case 3:
                        if( zone.get_options().query() ) {
                            stuff_changed = true;
                        }
                        break;
                    case 4: {
                        const auto pos = query_position();
                        if( pos && ( pos->first != zone.get_start_point() ||
                                     pos->second != zone.get_end_point() ) ) {
                            zone.set_position( *pos );
                            stuff_changed = true;
                        }
                        break;
                    }
                    case 5: {
                        on_out_of_scope invalidate_current_ui( [&]() {
                            ui.mark_resize();
                        } );
                        restore_on_out_of_scope<bool> show_prev( show );
                        restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
                        restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
                        show = false;
                        zone_start = cata::nullopt;
                        zone_end = cata::nullopt;
                        ui.mark_resize();
                        static_popup message_pop;
                        message_pop.on_top( true );
                        message_pop.message( "%s", _( "Moving zone." ) );
                        const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
                        const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
                        // local position of the zone center, used to calculate the u.view_offset,
                        // could center the screen to the position it represents
                        auto view_center = m.getlocal( zone.get_center_point() );
                        const look_around_result result_local = look_around( false, view_center,
                                                                zone_local_start_point, false, false,
                                                                false, true, zone_local_end_point );
                        if( result_local.position ) {
                            const auto new_start_point = m.getabs( *result_local.position );
                            if( new_start_point == zone.get_start_point() ) {
                                break; // Nothing changed, don't save
                            }
 
                            const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
                            zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
                            stuff_changed = true;
                        }
                    }
                    break;
                    default:
                        break;
                }
 
                blink = false;
            } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
                if( active_index < zone_cnt - 1 ) {
                    mgr.swap( zones[active_index], zones[active_index + 1] );
                    zones = get_zones();
                    active_index++;
                }
                blink = false;
                stuff_changed = true;
 
            } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
                if( active_index > 0 ) {
                    mgr.swap( zones[active_index], zones[active_index - 1] );
                    zones = get_zones();
                    active_index--;
                }
                blink = false;
                stuff_changed = true;
 
            } else if( action == "SHOW_ZONE_ON_MAP" ) {
                //show zone position on overmap;
                tripoint_abs_omt player_overmap_position = u.global_omt_location();
                // TODO: fix point types
                tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
 
                ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
            } else if( action == "ENABLE_ZONE" ) {
                zones[active_index].get().set_enabled( true );
 
                stuff_changed = true;
 
            } else if( action == "DISABLE_ZONE" ) {
                zones[active_index].get().set_enabled( false );
 
                stuff_changed = true;
            }
        }
 
        if( zone_cnt > 0 ) {
            blink = !blink;
            const auto &zone = zones[active_index].get();
            zone_start = m.getlocal( zone.get_start_point() );
            zone_end = m.getlocal( zone.get_end_point() );
            ctxt.set_timeout( BLINK_SPEED );
        } else {
            blink = false;
            zone_start = zone_end = cata::nullopt;
            ctxt.reset_timeout();
        }
 
        // Actually accessed from the terrain overlay callback `zone_cb` in the
        // call to `ui_manager::redraw`.
        //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
        zone_blink = blink;
        invalidate_main_ui_adaptor();
 
        ui_manager::redraw();
 
        //Wait for input
        action = ctxt.handle_input();
    } while( action != "QUIT" );
    zones_manager_open = false;
    ctxt.reset_timeout();
    zone_cb = nullptr;
 
    if( stuff_changed ) {
        auto &zones = zone_manager::get_manager();
        if( query_yn( _( "Save changes?" ) ) ) {
            zones.save_zones();
        } else {
            zones.load_zones();
        }
 
        zones.cache_data();
    }
 
    u.view_offset = stored_view_offset;
}

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

zoom_in()

void game::zoom_in

(

)

Definition at line 7314 of file game.cpp.

{
#if defined(TILES)
    if( tileset_zoom == 64 ) {
        tileset_zoom = MAXIMUM_ZOOM_LEVEL;
    } else {
        tileset_zoom = tileset_zoom * 2;
    }
    rescale_tileset( tileset_zoom );
#endif
}

References tileset_zoom.

Referenced by handle_action(), and look_around().

zoom_out()

void game::zoom_out

(

)

Definition at line 7302 of file game.cpp.

{
#if defined(TILES)
    if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
        tileset_zoom = tileset_zoom / 2;
    } else {
        tileset_zoom = 64;
    }
    rescale_tileset( tileset_zoom );
#endif
}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

advanced_inventory

friend class advanced_inventory

friend

Definition at line 146 of file game.h.

Creature_range

friend class Creature_range

friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

editmap

friend class editmap

friend

Definition at line 145 of file game.h.

get_avatar

avatar & get_avatar ( )

friend

Definition at line 100 of file avatar.cpp.

{
    return g->u;
}

get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )

friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12581 of file game.cpp.

{
    return *g->grid_tracker_ptr;
}

get_map

map & get_map ( )

friend

Definition at line 141 of file map.cpp.

{
    return g->m;
}

Referenced by extended_description(), and print_terrain_info().

get_player_character

Character & get_player_character ( )

friend

Definition at line 376 of file character.cpp.

{
    return g->u;
}

get_weather

weather_manager & get_weather ( )

friend

Definition at line 64 of file weather.cpp.

{
    return *g->weather_manager_ptr;
}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

main_menu

friend class main_menu

friend

Definition at line 147 of file game.h.

monster_range

friend class monster_range

friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr

private

Definition at line 1003 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

active_npc

std::list<shared_ptr_fast<npc> > game::active_npc

private

Definition at line 1085 of file game.h.

Referenced by cleanup_dead(), critter_at(), load_npcs(), game::npc_range::npc_range(), num_creatures(), setup(), shared_from(), unload_npcs(), update_map(), and vertical_move().

auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1066 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

bVMonsterLookFire

bool game::bVMonsterLookFire = false

private

Definition at line 1083 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

coming_to_stairs

std::vector<monster> game::coming_to_stairs

Definition at line 1031 of file game.h.

Referenced by replace_stair_monsters(), serialize(), setup(), unserialize(), update_stair_monsters(), and vertical_move().

critter_died

bool game::critter_died = false

private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1097 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

critter_tracker

pimpl<Creature_tracker> game::critter_tracker

Definition at line 1021 of file game.h.

Referenced by cleanup_dead(), clear_zombies(), critter_at(), game::monster_range::monster_range(), num_creatures(), place_critter_around(), place_critter_within(), remove_zombie(), serialize(), shared_from(), shift_monsters(), spawn_hallucination(), start_game(), swap_critters(), unserialize(), update_zombie_pos(), and vertical_move().

debug_hour_timer

class game::debug_hour_timer game::debug_hour_timer

private

debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1047 of file game.h.

debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1048 of file game.h.

destination_preview

std::vector<tripoint> game::destination_preview

private

Definition at line 1114 of file game.h.

Referenced by draw_ter(), handle_action(), shift_destination_preview(), try_get_left_click_action(), and try_get_right_click_action().

displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1060 of file game.h.

displaying_overlays

cata::optional<action_id> game::displaying_overlays

private

Definition at line 967 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1058 of file game.h.

Referenced by display_visibility().

draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks

private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

driving_view_offset

point game::driving_view_offset

Definition at line 1045 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

event_bus_ptr

pimpl<event_bus> game::event_bus_ptr

private

Definition at line 1001 of file game.h.

Referenced by events().

faction_manager_ptr

pimpl<faction_manager> game::faction_manager_ptr

Definition at line 1022 of file game.h.

Referenced by display_faction_epilogues(), handle_action(), perhaps_add_random_npc(), serialize_master(), setup(), and unserialize_master().

first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true

private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1099 of file game.h.

Referenced by do_turn(), and game().

follower_ids

std::set<character_id> game::follower_ids

private

Definition at line 1087 of file game.h.

Referenced by add_npc_follower(), death_screen(), disp_NPC_epilogues(), get_follower_list(), remove_npc_follower(), reset_npc_dispositions(), and setup().

fullscreen

bool game::fullscreen = false

Definition at line 1064 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), temp_exit_fullscreen(), and toggle_fullscreen().

gamemode

std::unique_ptr<special_game> game::gamemode

private

Definition at line 1103 of file game.h.

Referenced by cleanup_at_end(), death_screen(), do_turn(), gametype(), handle_action(), has_gametype(), load(), and start_game().

grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr

private

Definition at line 1007 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

is_looking

bool game::is_looking = false

private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr

private

Definition at line 1004 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll

private

Definition at line 1116 of file game.h.

Referenced by mouse_edge_scrolling().

last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap

private

Definition at line 1118 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain

private

Definition at line 1117 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

last_save_timestamp

time_t game::last_save_timestamp

private

Definition at line 1089 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels

mutableprivate

Definition at line 1090 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

list_item_downvote

std::string game::list_item_downvote

private

Definition at line 1080 of file game.h.

Referenced by list_items().

list_item_upvote

std::string game::list_item_upvote

private

Definition at line 1079 of file game.h.

Referenced by list_items().

liveview

live_view& game::liveview

private

Definition at line 998 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

liveview_ptr

pimpl<live_view> game::liveview_ptr

private

Definition at line 997 of file game.h.

m

map& game::m

Definition at line 1011 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), and zones_manager().

main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor

private

Definition at line 1122 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), invalidate_main_ui_adaptor(), and mark_main_ui_adaptor_resize().

map_ptr

pimpl<map> game::map_ptr

private

Definition at line 995 of file game.h.

memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr

private

Definition at line 1005 of file game.h.

Referenced by game(), and memorial().

monstairz

int game::monstairz = 0

Definition at line 1032 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

mostseen

int game::mostseen = 0

Definition at line 1071 of file game.h.

Referenced by handle_action(), load(), mon_info_update(), place_player(), serialize(), start_game(), and unserialize().

moves_since_last_save

int game::moves_since_last_save = 0

private

Definition at line 1088 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1028 of file game.h.

Referenced by do_turn(), setup(), and start_game().

next_mission_id

int game::next_mission_id = 0

private

Definition at line 1086 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

next_npc_id

character_id game::next_npc_id

private

Definition at line 1084 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

npcs_dirty

bool game::npcs_dirty = false

private

Has a NPC been spawned since last load?

Definition at line 1095 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

queue_screenshot

bool game::queue_screenshot = false

Definition at line 1067 of file game.h.

Referenced by do_turn().

remoteveh_cache

vehicle* game::remoteveh_cache

private

Definition at line 1093 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

remoteveh_cache_time

time_point game::remoteveh_cache_time

private

Definition at line 1092 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

right_sidebar

bool game::right_sidebar = false

Definition at line 1063 of file game.h.

safe_mode

safe_mode_type game::safe_mode

Definition at line 1068 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), load(), mon_info_update(), serialize(), set_safe_mode(), start_game(), and unserialize().

safe_mode_warning_logged

bool game::safe_mode_warning_logged = false

private

Definition at line 1082 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

scen

const scenario* game::scen

Definition at line 1030 of file game.h.

Referenced by start_calendar(), and start_game().

scent

scent_map& game::scent

Definition at line 1013 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

scent_ptr

pimpl<scent_map> game::scent_ptr

private

Definition at line 999 of file game.h.

seed

unsigned int game::seed = 0

private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1111 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

sFilter

std::string game::sFilter

private

Definition at line 1078 of file game.h.

Referenced by list_items(), and reset_item_list_state().

show_panel_adm

bool game::show_panel_adm = false

Definition at line 1062 of file game.h.

Referenced by draw_panels(), and load_static_data().

spell_events_ptr

pimpl<spell_events> game::spell_events_ptr

private

Definition at line 1006 of file game.h.

Referenced by game(), and spell_events_subscriber().

stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr

private

Definition at line 1002 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

ter_view_p

tripoint game::ter_view_p

Definition at line 1034 of file game.h.

Referenced by draw(), and draw_ter().

tileset_zoom

int game::tileset_zoom = 0

private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1108 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr

private

Definition at line 1000 of file game.h.

timed_events

timed_event_manager& game::timed_events

Definition at line 1014 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1023 of file game.h.

Referenced by serialize(), setup(), and unserialize().

turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1069 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

u

avatar& game::u

Definition at line 1012 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), favorite_ammo_or_select(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), inventory_item_menu(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), reload(), reload_item(), reload_weapon(), reload_wielded(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unload(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), win(), win_screen(), and zones_manager().

u_ptr

pimpl<avatar> game::u_ptr

private

Definition at line 996 of file game.h.

u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr

private

Definition at line 1073 of file game.h.

Referenced by shared_from().

uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1026 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

user_action_counter

int game::user_action_counter = 0

private

Definition at line 1105 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

w_minimap

catacurses::window game::w_minimap

Definition at line 1038 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

w_minimap_ptr

catacurses::window game::w_minimap_ptr

private

Definition at line 1076 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

w_omlegend

catacurses::window game::w_omlegend

Definition at line 1037 of file game.h.

w_overmap

catacurses::window game::w_overmap

Definition at line 1036 of file game.h.

w_pixel_minimap

catacurses::window game::w_pixel_minimap

Definition at line 1039 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), draw_pixel_minimap(), look_around(), and toggle_pixel_minimap().

w_terrain

catacurses::window game::w_terrain

Definition at line 1035 of file game.h.

Referenced by calc_driving_offset(), create_or_get_main_ui_adaptor(), display_scent(), draw(), draw_critter(), draw_critter_highlighted(), draw_cursor(), draw_look_around_cursor(), draw_ter(), draw_veh_dir_indicator(), draw_weather(), draw_zones(), handle_action(), handle_mouseview(), is_in_viewport(), look_around(), and pickup().

w_terrain_ptr

catacurses::window game::w_terrain_ptr

private

Definition at line 1075 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

wait_popup

std::unique_ptr<static_popup> game::wait_popup

private

Definition at line 1124 of file game.h.

Referenced by do_turn().

was_fullscreen

bool game::was_fullscreen = false

Definition at line 1065 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr

private

Definition at line 1008 of file game.h.

zones_manager_open

bool game::zones_manager_open = false

private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1101 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().

---

The documentation for this class was generated from the following files:

• src/game.h
• src/animation.cpp
• src/descriptions.cpp
• src/dump.cpp
• src/game.cpp
• src/game_inventory.cpp
• src/grab.cpp
• src/handle_action.cpp
• src/item_action.cpp
• src/mission_ui.cpp
• src/npctalk.cpp
• src/savegame.cpp